diff --git a/packages/demo/src/lib/PuzzleGrid.svelte b/packages/demo/src/lib/PuzzleGrid.svelte
index ceb8689..751f23a 100644
--- a/packages/demo/src/lib/PuzzleGrid.svelte
+++ b/packages/demo/src/lib/PuzzleGrid.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { findPositionCategory, type Grid } from "logic-grid";
+  import { displayAxisCategory, type Grid } from "logic-grid";
   import type { CellState } from "./puzzle-state.svelte";
 
   let {
@@ -16,13 +16,15 @@
     onEliminate: (valueIdx: number, position: number) => void;
   } = $props();
 
-  const posCat = $derived(findPositionCategory(puzzleGrid));
+  // The display-axis category provides column headers. It's identity-pinned,
+  // so its values are excluded from the mystery rows.
+  const posCat = $derived(displayAxisCategory(puzzleGrid));
 
-  /** Categories to display as rows (excludes position category). */
+  /** Categories to display as rows (excludes display-axis category). */
   const displayCategories = $derived(
     puzzleGrid.categories
       .map((cat, idx) => ({ cat, idx }))
-      .filter(({ cat }) => !cat.isPosition),
+      .filter(({ cat }) => cat !== posCat),
   );
 
   /** Compute the flat value index using the full categories array. */
@@ -94,13 +96,13 @@
       <tr>
         <th class="category-header"></th>
         <th class="value-header"></th>
-        <th class="position-noun-header" colspan={grid.size}>{posCat ? posCat.name : grid.positionNoun[1]}</th>
+        <th class="position-noun-header" colspan={grid.size}>{posCat.name}</th>
       </tr>
       <tr>
         <th class="category-header"></th>
         <th class="value-header"></th>
         {#each Array(grid.size) as _, p}
-          <th class="position-number">{posCat ? posCat.values[p] : p + 1}</th>
+          <th class="position-number">{posCat.displayLabels?.[p] ?? posCat.values[p]}</th>
         {/each}
       </tr>
     </thead>
diff --git a/packages/demo/src/lib/puzzle-state.svelte.ts b/packages/demo/src/lib/puzzle-state.svelte.ts
index 13e8efa..f396bf1 100644
--- a/packages/demo/src/lib/puzzle-state.svelte.ts
+++ b/packages/demo/src/lib/puzzle-state.svelte.ts
@@ -1,7 +1,7 @@
 import {
   generate,
   deduce,
-  findPositionCategory,
+  displayAxisCategory,
   type Category,
   type Puzzle,
   type Difficulty,
@@ -31,21 +31,11 @@ export function createPuzzleState() {
     theme?: string;
     clueStyle?: string;
     customCategories?: Category[];
-    positionNoun?: [string, string];
-    positionPreposition?: string;
   }
 
   function newPuzzle(opts: NewPuzzleOptions) {
-    const {
-      size,
-      categories,
-      difficulty,
-      theme,
-      clueStyle,
-      customCategories,
-      positionNoun,
-      positionPreposition,
-    } = opts;
+    const { size, categories, difficulty, theme, clueStyle, customCategories } =
+      opts;
     loading = true;
     loadingMessage = theme ? "Generating theme…" : "Generating…";
     message = null;
@@ -78,8 +68,6 @@ export function createPuzzleState() {
               difficulty,
               seed: Date.now(),
               categoryNames: themeResult.categories,
-              positionNoun: themeResult.positionNoun,
-              positionPreposition: themeResult.positionPreposition,
             });
           } else {
             puzzle = generate({
@@ -88,8 +76,6 @@ export function createPuzzleState() {
               difficulty,
               seed: Date.now(),
               categoryNames: customCategories,
-              positionNoun,
-              positionPreposition,
             });
           }
           if (clueStyle && puzzle) {
@@ -135,15 +121,13 @@ export function createPuzzleState() {
         grid = Array.from({ length: totalValues }, () =>
           Array.from({ length: puzzle!.grid.size }, () => "empty" as CellState),
         );
-        // Pre-confirm position category (identity assignment, not a mystery)
-        const posCat = findPositionCategory(puzzle.grid);
-        if (posCat) {
-          const posCatIdx = puzzle.grid.categories.indexOf(posCat);
-          for (let vi = 0; vi < posCat.values.length; vi++) {
-            const valueIdx = getValueIndex(posCatIdx, vi);
-            for (let p = 0; p < puzzle.grid.size; p++) {
-              grid[valueIdx][p] = p === vi ? "confirmed" : "eliminated";
-            }
+        // Pre-confirm the display-axis category (identity-assigned, not a mystery)
+        const displayCat = displayAxisCategory(puzzle.grid);
+        const displayCatIdx = puzzle.grid.categories.indexOf(displayCat);
+        for (let vi = 0; vi < displayCat.values.length; vi++) {
+          const valueIdx = getValueIndex(displayCatIdx, vi);
+          for (let p = 0; p < puzzle.grid.size; p++) {
+            grid[valueIdx][p] = p === vi ? "confirmed" : "eliminated";
           }
         }
         hintSteps = [];
@@ -431,7 +415,7 @@ export function createPuzzleState() {
     for (const candidate of hintSteps) {
       const newElims = candidate.eliminations.filter((e) => {
         const cell = grid[findValueIdx(e.value)][e.position];
-        return cell === "empty" || cell === "confirmed";
+        return cell === "empty";
       });
       const newAssigns = candidate.assignments.filter((a) => {
         return grid[findValueIdx(a.value)][a.position] !== "confirmed";
diff --git a/packages/demo/src/routes/+page.svelte b/packages/demo/src/routes/+page.svelte
index 5fccd70..b1a3c97 100644
--- a/packages/demo/src/routes/+page.svelte
+++ b/packages/demo/src/routes/+page.svelte
@@ -10,8 +10,6 @@
     label: string;
     size: number;
     categories: Category[];
-    positionNoun: [string, string];
-    positionPreposition: string;
   }
 
   const presets: Record<string, Preset> = {
@@ -26,7 +24,7 @@
           noun: "fund",
           verb: ["has a return of", "does not have a return of"],
           subjectPriority: -1,
-          isPosition: true,
+          ordered: true,
           numericValues: [3, 5, 8, 12],
           orderingPhrases: {
             unit: ["percentage point", "percentage points"],
@@ -36,8 +34,8 @@
                 "has the next lower return than",
                 "has the next higher return than",
               ],
-              next_to: "has an adjacent return to",
-              not_next_to: "does not have an adjacent return to",
+              next_to: "has the return right above or below",
+              not_next_to: "does not have the return right above or below",
               between: "has a return somewhere between",
               not_between: "does not have a return between",
               exact_distance: "is exactly",
@@ -47,8 +45,6 @@
         { name: "Strategy", values: ["Long/Short", "Macro", "Quant", "Event-Driven"], noun: "strategist", subjectPriority: 1, verb: ["uses the", "does not use the"], valueSuffix: "strategy" },
         { name: "City", values: ["New York", "London", "Tokyo", "Zurich"], noun: "office", subjectPriority: 1, verb: ["is based in", "is not based in"] },
       ],
-      positionNoun: ["fund", "funds"],
-      positionPreposition: "at",
     },
     "morning-schedule": {
       label: "Morning Schedule",
@@ -61,7 +57,7 @@
           noun: "slot",
           verb: ["has an appointment at", "does not have an appointment at"],
           subjectPriority: -1,
-          isPosition: true,
+          ordered: true,
           numericValues: [7, 8, 9, 10],
           orderingPhrases: {
             unit: ["hour", "hours"],
@@ -71,11 +67,11 @@
                 "has a later appointment than",
               ],
               left_of: [
-                "has an appointment exactly one hour before",
-                "has an appointment exactly one hour after",
+                "has the appointment right before",
+                "has the appointment right after",
               ],
-              next_to: "has an appointment within one hour of",
-              not_next_to: "does not have an appointment within one hour of",
+              next_to: "has an appointment right before or after",
+              not_next_to: "does not have an appointment right before or after",
               between: "has an appointment somewhere between",
               not_between: "does not have an appointment between",
               exact_distance: "has an appointment exactly",
@@ -85,8 +81,55 @@
         { name: "Activity", values: ["Dentist", "Barber", "Therapist", "Optician"], noun: "attendee", subjectPriority: 1, verb: ["visits the", "does not visit the"] },
         { name: "Transport", values: ["Bus", "Bike", "Car", "Walk"], noun: "commuter", subjectPriority: 1, verb: ["takes the", "does not take the"] },
       ],
-      positionNoun: ["slot", "slots"],
-      positionPreposition: "at",
+    },
+    "hedge-fund-multi": {
+      label: "Hedge Funds (Multi-Axis)",
+      size: 4,
+      categories: [
+        { name: "Manager", values: ["Nadine", "Sal", "Terry", "Walter"], noun: "", subjectPriority: 2 },
+        {
+          name: "Year",
+          values: ["1972", "1983", "1997", "2005"],
+          noun: "fund",
+          verb: ["started in", "did not start in"],
+          subjectPriority: -1,
+          ordered: true,
+          numericValues: [1972, 1983, 1997, 2005],
+          orderingPhrases: {
+            unit: ["year", "years"],
+            comparators: {
+              before: ["started earlier than", "started later than"],
+              left_of: ["started right before", "started right after"],
+              next_to: "started right before or after",
+              not_next_to: "did not start right before or after",
+              between: "started between",
+              not_between: "did not start between",
+              exact_distance: "started exactly",
+            },
+          },
+        },
+        {
+          name: "Return",
+          values: ["6%", "7%", "8%", "9%"],
+          noun: "fund",
+          verb: ["has a return of", "does not have a return of"],
+          subjectPriority: -1,
+          ordered: true,
+          orderingPhrases: {
+            unit: ["percentage point", "percentage points"],
+            comparators: {
+              before: ["has a lower return than", "has a higher return than"],
+              left_of: ["has the next lower return than", "has the next higher return than"],
+              next_to: "has the return right above or below",
+              not_next_to: "does not have the return right above or below",
+              between: "has a return between",
+              not_between: "does not have a return between",
+              exact_distance: "is exactly",
+            },
+          },
+        },
+        { name: "Fund", values: ["Black River", "Citizen Trust", "Pine Bay", "Silver Rock"], noun: "fund", subjectPriority: 1, verb: ["runs the", "does not run the"], valueSuffix: "fund" },
+      ],
     },
   };
 
@@ -108,8 +151,6 @@
         difficulty: diff,
         clueStyle: style,
         customCategories: p.categories,
-        positionNoun: p.positionNoun,
-        positionPreposition: p.positionPreposition,
       });
     } else {
       puzzleState.newPuzzle({
diff --git a/packages/logic-grid-ai/README.md b/packages/logic-grid-ai/README.md
index 6249083..1d0500c 100644
--- a/packages/logic-grid-ai/README.md
+++ b/packages/logic-grid-ai/README.md
@@ -24,22 +24,18 @@ const theme = await generateTheme({
 // {
 //   categories: [
 //     { name: "Pirate", values: ["Blackbeard", "Redbeard", ...], noun: "" },
-//     { name: "Ship", values: ["Revenge", "Kraken", ...], noun: "captain", verb: ["commands the", ...] },
+//     { name: "Ship", values: ["Revenge", "Kraken", ...], noun: "captain",
+//       verb: ["commands the", ...], ordered: true, orderingPhrases: { comparators: {...} } },
 //     ...
-//   ],
-//   positionNoun: ["cove", "coves"],
-//   positionPreposition: "at"
+//   ]
 // }
 
 const puzzle = generate({
   size: 4,
   categories: 4,
   categoryNames: theme.categories,
-  positionNoun: theme.positionNoun,
-  positionPreposition: theme.positionPreposition,
 });
 // Clues like: "Blackbeard commands the Revenge."
-// "The gold seeker is at the first cove."
 ```
 
 ## API
@@ -63,12 +59,10 @@ Returns a `ThemeResult`:
 ```typescript
 interface ThemeResult {
   categories: Category[]; // from logic-grid
-  positionNoun: [string, string]; // [singular, plural], e.g. ["planet", "planets"]
-  positionPreposition: string; // e.g. "on" -> "lives on the first planet"
 }
 ```
 
-The result is validated against structural and semantic rules (value uniqueness, noun consistency, category count, etc.). If validation fails, the AI is retried with error feedback up to 3 times.
+At least one category must have `ordered: true` with `orderingPhrases.comparators` defining all 7 comparator phrases. The result is validated against structural and semantic rules (value uniqueness, noun consistency, category count, ordered category presence, etc.). If validation fails, the AI is retried with error feedback up to 3 times.
 
 ### `createAnthropicClient(apiKey?)`
 
@@ -116,9 +110,9 @@ if (errors.length > 0) {
 
 ## How It Works
 
-1. A detailed prompt describes the puzzle structure, category contract, and position noun semantics
+1. A detailed prompt describes the puzzle structure, category contract, and ordering semantics
 2. The AI responds via tool_use with structured JSON matching a strict schema
-3. The response is validated (category count, value uniqueness, noun consistency, etc.)
+3. The response is validated (category count, value uniqueness, noun consistency, ordered category presence, comparator completeness, etc.)
 4. If validation fails, errors are fed back to the AI for up to 3 retries
 
 ## License
diff --git a/packages/logic-grid-ai/src/rewrite.test.ts b/packages/logic-grid-ai/src/rewrite.test.ts
index e2aa2ca..42cedcb 100644
--- a/packages/logic-grid-ai/src/rewrite.test.ts
+++ b/packages/logic-grid-ai/src/rewrite.test.ts
@@ -11,7 +11,7 @@ const SAMPLE_CLUES: Clue[] = [
     text: "Alice drinks coffee.",
   },
   {
-    constraint: { type: "next_to", a: "Cat", b: "Red" },
+    constraint: { type: "next_to", a: "Cat", b: "Red", axis: "House" },
     text: "The cat lives next to the red house.",
   },
   {
diff --git a/packages/logic-grid-ai/src/theme.test.ts b/packages/logic-grid-ai/src/theme.test.ts
index 9116fa2..14aa9e1 100644
--- a/packages/logic-grid-ai/src/theme.test.ts
+++ b/packages/logic-grid-ai/src/theme.test.ts
@@ -22,6 +22,18 @@ const VALID_THEME: ThemeResult = {
       values: ["Galleon", "Brigantine", "Sloop", "Frigate"],
       noun: "captain",
       verb: ["sails the", "does not sail the"],
+      ordered: true,
+      orderingPhrases: {
+        comparators: {
+          before: ["sails before", "sails after"],
+          left_of: ["sails right before", "sails right after"],
+          next_to: "sails right next to",
+          not_next_to: "does not sail right next to",
+          between: "sails between",
+          not_between: "does not sail between",
+          exact_distance: "sails exactly",
+        },
+      },
     },
     {
       name: "Treasure",
@@ -36,8 +48,6 @@ const VALID_THEME: ThemeResult = {
       verb: ["wields the", "does not wield the"],
     },
   ],
-  positionNoun: ["spot", "spots"],
-  positionPreposition: "at",
 };
 
 describe("generateTheme", () => {
@@ -51,8 +61,6 @@ describe("generateTheme", () => {
 
     expect(result.categories).toHaveLength(4);
     expect(result.categories[0].noun).toBe("");
-    expect(result.positionNoun).toEqual(["spot", "spots"]);
-    expect(result.positionPreposition).toBe("at");
   });
 
   it("uses default Anthropic client when none provided", async () => {
@@ -125,9 +133,14 @@ describe("generateTheme", () => {
   });
 
   it("throws after max retries", async () => {
+    // No ordered category → validation fails
     const badResult: ThemeResult = {
-      ...VALID_THEME,
-      positionPreposition: "",
+      categories: VALID_THEME.categories.map((c) => ({
+        name: c.name,
+        values: c.values,
+        noun: c.noun,
+        verb: c.verb,
+      })),
     };
 
     await expect(
@@ -191,21 +204,17 @@ describe("generateTheme", () => {
 
     const puzzle = generate({
       categoryNames: theme.categories,
-      positionNoun: theme.positionNoun,
-      positionPreposition: theme.positionPreposition,
       size: 4,
       seed: 0,
     });
 
     expect(puzzle.grid.size).toBe(4);
     expect(puzzle.grid.categories).toHaveLength(4);
-    expect(puzzle.grid.positionNoun).toEqual(["spot", "spots"]);
-    expect(puzzle.grid.positionPreposition).toBe("at");
     expect(puzzle.clues.length).toBeGreaterThan(0);
     expect(puzzle.solution).toBeDefined();
 
-    // Verify clues use the custom position noun
-    const positionalClue = puzzle.clues.find((c) => c.text.includes("spot"));
-    expect(positionalClue).toBeDefined();
+    // Verify clues render with the Ship category's verb/comparators
+    const sailClue = puzzle.clues.find((c) => c.text.includes("sail"));
+    expect(sailClue).toBeDefined();
   });
 });
diff --git a/packages/logic-grid-ai/src/theme.ts b/packages/logic-grid-ai/src/theme.ts
index 6b911bc..b1303a2 100644
--- a/packages/logic-grid-ai/src/theme.ts
+++ b/packages/logic-grid-ai/src/theme.ts
@@ -50,10 +50,10 @@ function buildSchema(size: number, categories: number): JSONSchema {
         description:
           'Optional [positive, negative] verb pair for at_position inversion. Set this ONLY when the category\'s values are adjectives that describe the position noun directly (e.g. Color "Red" describes "house"). Inverts at_position to "{posLabel} {verb} {value}" → "The first house is red." Use ["is", "is not"] in most cases. Always pair with valueSuffix and subjectPriority -1.',
       },
-      isPosition: {
+      ordered: {
         type: "boolean",
         description:
-          "If true, this category defines the positional axis. Its values are the position labels (e.g. sorted returns, years, times). At most one category can be isPosition. Its assignment is identity (value[0] → position 0, etc.), so it is not a mystery.",
+          "If true, the values array order is canonical. Comparative constraints (before, left_of, next_to, between, exact_distance) can reference this category as their axis. At least one category per theme must be ordered. numericValues and orderingPhrases are only legal on ordered categories.",
       },
       numericValues: {
         type: "array",
@@ -96,21 +96,8 @@ function buildSchema(size: number, categories: number): JSONSchema {
         maxItems: categories,
         description: `Exactly ${categories} categories`,
       },
-      positionNoun: {
-        type: "array",
-        items: { type: "string" },
-        minItems: 2,
-        maxItems: 2,
-        description:
-          'Singular and plural position noun, e.g. ["dock", "docks"]',
-      },
-      positionPreposition: {
-        type: "string",
-        description:
-          'Preposition for positional phrases, e.g. "at" → "lives at the first dock"',
-      },
     },
-    required: ["categories", "positionNoun", "positionPreposition"],
+    required: ["categories"],
   };
 }
 
@@ -142,25 +129,36 @@ The puzzle has ${size} positions. Clues are generated mechanically from categori
 **\`valueSuffix\`** — appends a clarifying noun after the value when it appears as an object. Use this when the value alone is an adjective or short label that needs a noun.
 - Strategy (valueSuffix: "strategy", verb: ["uses the", "does not use the"]) → "Alice uses the event-driven strategy."
 - Color (valueSuffix: "house") → "Alice lives in the red house."
+- Bounty with bare numbers (valueSuffix: "gold pieces") → "has a bounty of 500 gold pieces."
+
+**IMPORTANT for ordered categories with numeric values:** The \`unit\` field in orderingPhrases is ONLY used for \`exact_distance\` clues ("exactly 25 years from"). It is NOT appended to values in other clue types. If your ordered category has bare numeric values like "500", "1000" that need a unit label in all clues, use \`valueSuffix\` (e.g. valueSuffix: "gold pieces"). If values are already self-explanatory like "2005" (a year) or "7am" (a time), no suffix is needed.
 
 **\`positionAdjective\`** — set ONLY when the position noun is naturally modified by an adjective category, like a HOUSE has a color ("the red house"). DO NOT use this for position nouns like "dock", "ship", "fund", "station", "slot", "year" — these aren't naturally characterized by an adjective from another category. Provides a [positive, negative] verb pair (usually ["is", "is not"]) for at_position inversion: "The first house is red." MUST be paired with valueSuffix and subjectPriority -1. Use sparingly — when in doubt, don't.
 
-## Position noun
+## Ordered categories
 
-The position noun labels ordered slots. Default ["house", "houses"] with preposition "in" → "lives in the first house". Pick a thematic alternative: ["station", "stations"] preposition "at", ["dock", "docks"] preposition "at", etc.
+At least one category must have \`ordered: true\` so comparative constraints can reference it. Use ordered categories when the values have a canonical sequence (sorted returns, years, times, prices, house numbers). Ordered categories can carry:
+- numericValues: strictly ascending numbers matching the values, enabling value-based distance clues like "exactly 11 years apart"
+- orderingPhrases.unit: [singular, plural] for distance clues
+- orderingPhrases.comparators: full-phrase overrides describing the ordering. Keys: \`before\`, \`left_of\`, \`next_to\`, \`not_next_to\`, \`between\`, \`not_between\`, \`exact_distance\`. Each is either a string (forward only) or a [forward, reverse] tuple. Symmetric comparators (\`next_to\`, \`not_next_to\`, \`between\`, \`not_between\`, \`exact_distance\`) MUST be a single string.
+- For directional comparators (\`before\` and \`left_of\`), prefer the tuple form for phrasing variety: e.g. \`["has a lower return than", "has a higher return than"]\`.
 
-## Position categories (optional, advanced)
+**HOW COMPARATORS RENDER:** Each comparator phrase is inserted verbatim into \`"{Subject} {comparator} {Object}."\` For example: \`"has a lower return than"\` → "Alice has a lower return than Bob."
 
-Mark ONE category isPosition: true to define the positional axis. Its values ARE the positions (sorted). Use this when the theme has a natural numeric ordering (returns, times, years, prices). The position category should also have:
-- noun, verb (used for at_position rendering)
-- subjectPriority: -1 (always object)
-- numericValues: strictly ascending numbers matching the values
-- orderingPhrases.unit: [singular, plural] for distance clues
-- orderingPhrases.comparators: full-phrase overrides describing the positional ordering. **You MUST set ALL of these keys**: \`before\`, \`left_of\`, \`next_to\`, \`not_next_to\`, \`between\`, \`not_between\`, \`exact_distance\`. They apply to ALL ordering clues in the puzzle (Manager↔Strategy, City↔Strategy, etc.), not just clues involving position values. Missing keys fall through to generic "is somewhere before / adjacent to / directly before" wording, which sounds wrong in a domain like returns.
-- For directional comparators (\`before\` and \`left_of\`), prefer the tuple form \`[forward, reverse]\` for phrasing variety: e.g. \`["has a lower return than", "has a higher return than"]\` lets clues say either "Alice has a lower return than Bob" or "Bob has a higher return than Alice" depending on which reads more naturally for that pair. Single string is also valid (forward only).
-- Symmetric comparators (\`next_to\`, \`not_next_to\`, \`between\`, \`not_between\`, \`exact_distance\`) MUST be a single string, not a tuple.
-- For \`left_of\`: this means "immediately preceding in the ordering". Phrase it without assuming equidistant gaps (avoid "exactly one X less than" unless your numericValues actually are equidistant).
-- For \`exact_distance\`: this is the verb prefix that goes BEFORE the distance number. E.g. \`"is exactly"\` produces "Alice is exactly 3 percentage points from Bob." Use \`"has a return exactly"\` if you want "Alice has a return exactly 3 percentage points from Bob."
+The phrase must be a grammatical verb phrase connecting two noun phrases. Test: say "Alice {phrase} Bob" and "The ramen cook {phrase} the french chef" — both must read naturally.
+
+**Comparators are REQUIRED** on every ordered category — all 7 keys must be set. There are no fallbacks; missing keys cause errors. \`before\` and \`left_of\` must be \`[forward, reverse]\` tuples. The other 5 (\`next_to\`, \`not_next_to\`, \`between\`, \`not_between\`, \`exact_distance\`) must be plain strings.
+
+Keep phrases short and simple. Examples of good patterns:
+- before: \`["scored lower than", "scored higher than"]\`
+- left_of: \`["scored right below", "scored right above"]\`
+- next_to: \`"scored right before or after"\`
+- not_next_to: \`"did not score right before or after"\`
+- between: \`"scored between"\`
+- not_between: \`"did not score between"\`
+- exact_distance: \`"scored exactly"\` (prefix before the distance number)
+
+**IMPORTANT — rank vs value phrasing:** \`next_to\` and \`left_of\` mean "adjacent in rank" (no other value between them), NOT "close in value" or "exactly 1 unit apart". With non-equidistant numericValues like [3, 5, 8, 12], rank-adjacent values have different gaps. NEVER use phrasing that implies specific value distances for these constraints: no "closest", "nearest", "adjacent to" (implies proximity), "within N units of", or "exactly one X before/after". Use rank-order phrasing instead: "right before or after", "right above or below", "scored right below/above". Only \`exact_distance\` may claim specific value gaps (it uses numericValues to compute the actual difference).
 
 ## Examples
 
@@ -173,8 +171,6 @@ For a "pirate adventure" theme with size 4 and 4 categories:
     { "name": "Treasure", "values": ["Gold", "Pearls", "Rubies", "Maps"], "noun": "hoarder", "subjectPriority": 1, "verb": ["hoards", "does not hoard"] },
     { "name": "Hideout", "values": ["Tortuga", "Nassau", "Madagascar", "Cuba"], "noun": "captain", "subjectPriority": 1, "verb": ["hides in", "does not hide in"] }
   ],
-  "positionNoun": ["dock", "docks"],
-  "positionPreposition": "at"
 }
 
 Note: Hideout has plain values ("Tortuga"), no valueSuffix needed because "hides in Tortuga" reads naturally. If values were "tortuga bay" they'd need valueSuffix: "hideout" → "hides in the tortuga bay hideout."
@@ -184,12 +180,10 @@ For a "hedge fund" theme:
 {
   "categories": [
     { "name": "Manager", "values": ["Alice", "Bob", "Clara", "Dan"], "noun": "", "subjectPriority": 2 },
-    { "name": "YTD Return", "values": ["3%", "5%", "8%", "12%"], "noun": "fund", "subjectPriority": -1, "verb": ["has a return of", "does not have a return of"], "isPosition": true, "numericValues": [3, 5, 8, 12], "orderingPhrases": { "unit": ["percentage point", "percentage points"], "comparators": { "before": ["has a lower return than", "has a higher return than"], "left_of": ["has the next lower return after", "has the next higher return after"], "next_to": "has an adjacent return to", "not_next_to": "does not have an adjacent return to", "between": "has a return between", "not_between": "does not have a return between", "exact_distance": "has a return exactly" } } },
+    { "name": "YTD Return", "values": ["3%", "5%", "8%", "12%"], "noun": "fund", "subjectPriority": -1, "verb": ["has a return of", "does not have a return of"], "ordered": true, "numericValues": [3, 5, 8, 12], "orderingPhrases": { "unit": ["percentage point", "percentage points"], "comparators": { "before": ["has a lower return than", "has a higher return than"], "left_of": ["has a return right below", "has a return right above"], "next_to": "has the return right above or below", "not_next_to": "does not have the return right above or below", "between": "has a return between", "not_between": "does not have a return between", "exact_distance": "has a return exactly" } } },
     { "name": "Strategy", "values": ["Long/Short", "Macro", "Quant", "Event-Driven"], "noun": "strategist", "subjectPriority": 1, "verb": ["uses the", "does not use the"], "valueSuffix": "strategy" },
     { "name": "City", "values": ["New York", "London", "Tokyo", "Zurich"], "noun": "office", "subjectPriority": 1, "verb": ["is based in", "is not based in"] }
   ],
-  "positionNoun": ["fund", "funds"],
-  "positionPreposition": "at"
 }
 
 ## Decision guide
@@ -199,7 +193,7 @@ For each category, ask:
 2. Are its values multi-word labels that describe the position noun (like "Crimson" describes "ship")? → set valueSuffix to the position noun, positionAdjective to ["is", "is not"], subjectPriority -1
 3. Are its values short labels needing a clarifying noun (like "Event-Driven" → "event-driven strategy")? → set valueSuffix, subjectPriority 1
 4. Does the value read naturally without a suffix in "{subject} {verb} {value}" form (like "Alice owns the cat", "Bob drinks tea", "Carol hides in tortuga")? → no valueSuffix needed, subjectPriority 1
-5. Does the theme have a numeric ordering axis (returns, times, years)? → mark ONE category isPosition with numericValues and orderingPhrases
+5. Does the theme have a natural ordering (returns, times, years, house numbers)? → mark that category ordered: true. For numeric orderings add numericValues and orderingPhrases
 
 ## Your task
 
@@ -211,7 +205,7 @@ Generate themed categories for: "${theme}"
 - Set subjectPriority on EVERY category (2 person, 1 animate, 0 neutral, -1 describer)
 - Set valueSuffix when values need a clarifying noun in object position
 - Verb pairs MUST read naturally in "{subject} {positive verb} {value}{valueSuffix?}"
-- Pick a thematic position noun and preposition`;
+- Every ordered category MUST have orderingPhrases.comparators with all 7 keys`;
 
   if (constraints && constraints.length > 0) {
     prompt += `\n- Additional constraints: ${constraints.join(", ")}`;
@@ -227,7 +221,7 @@ Generate themed categories for: "${theme}"
 /**
  * Generate themed categories for a logic grid puzzle using AI.
  *
- * Calls the AI client to produce categories, position noun, and preposition
+ * Calls the AI client to produce categories with ordering phrases
  * that fit the given theme. Validates the result and retries up to 3 times
  * if the AI output fails validation, feeding errors back into the prompt.
  *
diff --git a/packages/logic-grid-ai/src/types.ts b/packages/logic-grid-ai/src/types.ts
index b2d0d30..57a6b05 100644
--- a/packages/logic-grid-ai/src/types.ts
+++ b/packages/logic-grid-ai/src/types.ts
@@ -17,8 +17,6 @@ export interface ThemeOptions {
 /** Result of theme generation. */
 export interface ThemeResult {
   categories: Category[];
-  positionNoun: [string, string];
-  positionPreposition: string;
 }
 
 /** Minimal AI client interface. */
diff --git a/packages/logic-grid-ai/src/validation.test.ts b/packages/logic-grid-ai/src/validation.test.ts
index 43504f9..13689d0 100644
--- a/packages/logic-grid-ai/src/validation.test.ts
+++ b/packages/logic-grid-ai/src/validation.test.ts
@@ -1,8 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { validateThemeResult } from "./validation";
-import type { ThemeResult } from "./types";
 
-function validResult(): ThemeResult {
+function validResult() {
   return {
     categories: [
       {
@@ -14,17 +13,27 @@ function validResult(): ThemeResult {
         name: "Dish",
         values: ["Risotto", "Soufflé", "Ramen"],
         noun: "chef",
-        verb: ["prepares the", "does not prepare the"],
+        verb: ["prepares the", "does not prepare the"] as [string, string],
+        ordered: true,
+        orderingPhrases: {
+          comparators: {
+            before: "is before",
+            left_of: "is right before",
+            next_to: "is right next to",
+            not_next_to: "is not right next to",
+            between: "is between",
+            not_between: "is not between",
+            exact_distance: "is exactly",
+          },
+        },
       },
       {
         name: "Tool",
         values: ["Wok", "Blowtorch", "Cleaver"],
         noun: "user",
-        verb: ["wields the", "does not wield the"],
+        verb: ["wields the", "does not wield the"] as [string, string],
       },
     ],
-    positionNoun: ["station", "stations"],
-    positionPreposition: "at",
   };
 }
 
@@ -53,7 +62,7 @@ describe("validateThemeResult", () => {
 
   it("rejects duplicate values (case-insensitive)", () => {
     const r = validResult();
-    r.categories[2].values[0] = "gordon"; // same as Chef's "Gordon"
+    r.categories[2].values[0] = "gordon";
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining('Duplicate value "gordon"'),
@@ -78,89 +87,73 @@ describe("validateThemeResult", () => {
     );
   });
 
-  it("rejects whitespace-only noun", () => {
+  it("rejects invalid verb type", () => {
     const r = validResult();
-    r.categories[1].noun = "  ";
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining("whitespace-only noun"),
-    );
-  });
-
-  it("rejects invalid verb pair", () => {
-    const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[1].verb = ["only one"] as any;
+    r.categories[1].verb = ["only one"] as unknown as [string, string];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(expect.stringContaining("invalid verb"));
   });
 
-  it("rejects empty verb strings", () => {
+  it("rejects empty category name", () => {
     const r = validResult();
-    r.categories[1].verb = ["prepares the", ""];
+    (r.categories[0] as Record<string, unknown>).name = null;
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
-      expect.stringContaining("empty verb strings"),
+      expect.stringContaining("A category has an empty name"),
     );
   });
 
-  it("rejects null/undefined category name", () => {
+  it("rejects duplicate category names", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[0].name = null as any;
+    r.categories[2].name = "Dish";
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
-      expect.stringContaining("A category has an empty name"),
+      expect.stringContaining("Duplicate category name"),
     );
   });
 
-  it("rejects whitespace-only category name", () => {
+  it("rejects category with no values", () => {
     const r = validResult();
-    r.categories[0].name = "   ";
+    delete (r.categories[0] as Record<string, unknown>).values;
     const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining("A category has an empty name"),
-    );
+    expect(errors).toContainEqual(expect.stringContaining("has 0 values"));
   });
 
-  it("rejects empty values", () => {
+  it("rejects long category name", () => {
     const r = validResult();
-    r.categories[0].values[0] = "";
+    r.categories[0].name = "A".repeat(31);
     const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(expect.stringContaining("empty value"));
+    expect(errors).toContainEqual(expect.stringContaining("too long"));
   });
 
-  it("rejects values longer than 30 chars", () => {
+  it("rejects long value", () => {
     const r = validResult();
-    r.categories[0].values[0] = "A".repeat(31);
+    r.categories[0].values[0] = "X".repeat(31);
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(expect.stringContaining("too long"));
   });
 
-  it("rejects category name longer than 30 chars", () => {
+  it("rejects empty verb strings", () => {
     const r = validResult();
-    r.categories[0].name = "A".repeat(31);
+    r.categories[1].verb = ["", "does not"] as [string, string];
     const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(expect.stringContaining("too long"));
+    expect(errors).toContainEqual(expect.stringContaining("empty verb"));
   });
 
-  it("rejects duplicate category names (case-insensitive)", () => {
+  it("rejects whitespace-only noun", () => {
     const r = validResult();
-    r.categories[2].name = "dish";
+    r.categories[1].noun = "  ";
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
-      expect.stringContaining("Duplicate category name"),
+      expect.stringContaining("whitespace-only noun"),
     );
   });
 
-  it("rejects invalid positionNoun type", () => {
+  it("rejects duplicate noun", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.positionNoun = "station" as any;
+    r.categories[2].noun = "chef";
     const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining("positionNoun must be [singular, plural]"),
-    );
+    expect(errors).toContainEqual(expect.stringContaining("Duplicate noun"));
   });
 
   it("rejects values that collide with positional words", () => {
@@ -172,42 +165,6 @@ describe("validateThemeResult", () => {
     );
   });
 
-  it("rejects empty positionNoun", () => {
-    const r = validResult();
-    r.positionNoun = ["", "stations"];
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining("positionNoun strings must not be empty"),
-    );
-  });
-
-  it("rejects empty positionPreposition", () => {
-    const r = validResult();
-    r.positionPreposition = "";
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining("positionPreposition must be a non-empty string"),
-    );
-  });
-
-  it("rejects category name matching position noun", () => {
-    const r = validResult();
-    r.positionNoun = ["chef", "chefs"];
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining('Category name "Chef" matches the position noun'),
-    );
-  });
-
-  it("rejects category value matching position noun", () => {
-    const r = validResult();
-    r.positionNoun = ["wok", "woks"];
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining('Value "Wok" in category "Tool" matches'),
-    );
-  });
-
   it("rejects non-person category without verb", () => {
     const r = validResult();
     delete r.categories[1].verb;
@@ -218,35 +175,39 @@ describe("validateThemeResult", () => {
   it("reports multiple errors at once", () => {
     const r = validResult();
     r.categories[0].values[0] = "";
-    r.positionPreposition = "";
+    r.categories[0].values[1] = "";
     const errors = validateThemeResult(r, 3, 3);
     expect(errors.length).toBeGreaterThanOrEqual(2);
   });
 
-  it("accepts a valid position category", () => {
+  it("accepts an ordered category with numericValues and orderingPhrases", () => {
     const r = validResult();
-    r.categories[1].isPosition = true;
-    r.categories[1].numericValues = [1, 2, 3];
-    r.categories[1].orderingPhrases = {
+    (r.categories[1] as Record<string, unknown>).numericValues = [1, 2, 3];
+    (r.categories[1] as Record<string, unknown>).orderingPhrases = {
       unit: ["point", "points"],
       comparators: { before: "scores higher than" },
     };
     expect(validateThemeResult(r, 3, 3)).toEqual([]);
   });
 
-  it("rejects multiple position categories", () => {
+  it("rejects when no category is ordered", () => {
     const r = validResult();
-    r.categories[1].isPosition = true;
-    r.categories[2].isPosition = true;
+    delete (r.categories[1] as Record<string, unknown>).ordered;
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
-      expect.stringContaining("Multiple position categories"),
+      expect.stringContaining("No ordered category found"),
     );
   });
 
+  it("accepts multiple ordered categories", () => {
+    const r = validResult();
+    (r.categories[2] as Record<string, unknown>).ordered = true;
+    expect(validateThemeResult(r, 3, 3)).toEqual([]);
+  });
+
   it("rejects numericValues with wrong count", () => {
     const r = validResult();
-    r.categories[1].numericValues = [1, 2];
+    (r.categories[1] as Record<string, unknown>).numericValues = [1, 2];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("numericValues must have exactly 3 numbers"),
@@ -255,23 +216,16 @@ describe("validateThemeResult", () => {
 
   it("rejects non-numeric numericValues", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[1].numericValues = [1, "two", 3] as any;
+    (r.categories[1] as Record<string, unknown>).numericValues = [1, "two", 3];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("numericValues must all be numbers"),
     );
   });
 
-  it("accepts numericValues on non-position category", () => {
-    const r = validResult();
-    r.categories[1].numericValues = [10, 20, 30];
-    expect(validateThemeResult(r, 3, 3)).toEqual([]);
-  });
-
-  it("accepts orderingPhrases on non-position category", () => {
+  it("accepts orderingPhrases with unit on ordered category", () => {
     const r = validResult();
-    r.categories[1].orderingPhrases = {
+    (r.categories[1] as Record<string, unknown>).orderingPhrases = {
       unit: ["point", "points"],
     };
     expect(validateThemeResult(r, 3, 3)).toEqual([]);
@@ -279,51 +233,40 @@ describe("validateThemeResult", () => {
 
   it("rejects null orderingPhrases", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[1].orderingPhrases = null as any;
+    (r.categories[1] as Record<string, unknown>).orderingPhrases = null;
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("orderingPhrases must be an object"),
     );
   });
 
-  it("accepts valid valueSuffix", () => {
-    const r = validResult();
-    r.categories[1].valueSuffix = "strategy";
-    expect(validateThemeResult(r, 3, 3)).toEqual([]);
-  });
-
   it("rejects non-string valueSuffix", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[1].valueSuffix = 42 as any;
+    (r.categories[1] as Record<string, unknown>).valueSuffix = 42;
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("valueSuffix must be a string"),
     );
   });
 
-  it("accepts valid positionAdjective with valueSuffix", () => {
-    const r = validResult();
-    r.categories[1].valueSuffix = "house";
-    r.categories[1].positionAdjective = ["is", "is not"];
-    expect(validateThemeResult(r, 3, 3)).toEqual([]);
-  });
-
   it("rejects positionAdjective without valueSuffix", () => {
     const r = validResult();
-    r.categories[1].positionAdjective = ["is", "is not"];
+    (r.categories[1] as Record<string, unknown>).positionAdjective = [
+      "is",
+      "is not",
+    ];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
-      expect.stringContaining("positionAdjective but no valueSuffix"),
+      expect.stringContaining("has positionAdjective but no valueSuffix"),
     );
   });
 
-  it("rejects malformed positionAdjective", () => {
+  it("rejects invalid positionAdjective type", () => {
     const r = validResult();
-    r.categories[1].valueSuffix = "house";
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[1].positionAdjective = ["only one"] as any;
+    (r.categories[1] as Record<string, unknown>).valueSuffix = "house";
+    (r.categories[1] as Record<string, unknown>).positionAdjective = [
+      "only one",
+    ];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining(
@@ -332,15 +275,9 @@ describe("validateThemeResult", () => {
     );
   });
 
-  it("accepts valid subjectPriority", () => {
-    const r = validResult();
-    r.categories[1].subjectPriority = -1;
-    expect(validateThemeResult(r, 3, 3)).toEqual([]);
-  });
-
   it("rejects non-ascending numericValues", () => {
     const r = validResult();
-    r.categories[1].numericValues = [3, 1, 2];
+    (r.categories[1] as Record<string, unknown>).numericValues = [3, 1, 2];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("strictly ascending"),
@@ -349,7 +286,7 @@ describe("validateThemeResult", () => {
 
   it("rejects equal adjacent numericValues", () => {
     const r = validResult();
-    r.categories[1].numericValues = [1, 1, 2];
+    (r.categories[1] as Record<string, unknown>).numericValues = [1, 1, 2];
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("strictly ascending"),
@@ -358,11 +295,8 @@ describe("validateThemeResult", () => {
 
   it("rejects symmetric comparator as tuple", () => {
     const r = validResult();
-    r.categories[1].orderingPhrases = {
-      comparators: {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-        next_to: ["fwd", "rev"] as any,
-      },
+    (r.categories[1] as Record<string, unknown>).orderingPhrases = {
+      comparators: { next_to: ["fwd", "rev"] },
     };
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
@@ -372,31 +306,15 @@ describe("validateThemeResult", () => {
 
   it("accepts directional comparator as tuple", () => {
     const r = validResult();
-    r.categories[1].orderingPhrases = {
-      comparators: {
-        before: ["has a lower X than", "has a higher X than"],
-      },
+    (r.categories[1] as Record<string, unknown>).orderingPhrases = {
+      comparators: { before: ["has a lower X than", "has a higher X than"] },
     };
     expect(validateThemeResult(r, 3, 3)).toEqual([]);
   });
 
-  it("rejects positionAdjective with isPosition", () => {
-    const r = validResult();
-    r.categories[1].isPosition = true;
-    r.categories[1].valueSuffix = "house";
-    r.categories[1].positionAdjective = ["is", "is not"];
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining(
-        "cannot be both isPosition and positionAdjective",
-      ),
-    );
-  });
-
   it("rejects non-number subjectPriority", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
-    r.categories[1].subjectPriority = "high" as any;
+    (r.categories[1] as Record<string, unknown>).subjectPriority = "high";
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("subjectPriority must be a number"),
diff --git a/packages/logic-grid-ai/src/validation.ts b/packages/logic-grid-ai/src/validation.ts
index 27e2036..3302845 100644
--- a/packages/logic-grid-ai/src/validation.ts
+++ b/packages/logic-grid-ai/src/validation.ts
@@ -1,4 +1,19 @@
-import type { ThemeResult } from "./types";
+/** Loose shape for untrusted AI category output. All fields optional. */
+interface RawCategory {
+  name?: string;
+  values?: string[];
+  noun?: string;
+  verb?: [string, string];
+  subjectPriority?: number;
+  valueSuffix?: string;
+  positionAdjective?: [string, string];
+  ordered?: boolean;
+  numericValues?: number[];
+  orderingPhrases?: {
+    unit?: [string, string];
+    comparators?: Record<string, unknown>;
+  };
+}
 
 const POSITIONAL_WORDS = new Set([
   "first",
@@ -17,8 +32,13 @@ const POSITIONAL_WORDS = new Set([
  * Returns an array of error messages. Empty array means the result is valid.
  * Used internally by generateTheme to decide whether to retry.
  */
+/**
+ * The input shape is intentionally loose (`categories: Record<string, unknown>[]`)
+ * because this function validates untrusted AI JSON output. The caller
+ * (generateTheme) casts to ThemeResult only after validation passes.
+ */
 export function validateThemeResult(
-  result: ThemeResult,
+  result: { categories: readonly unknown[] },
   expectedSize: number,
   expectedCategories: number,
 ): string[] {
@@ -34,9 +54,10 @@ export function validateThemeResult(
   const seenValues = new Map<string, string>();
   const seenNouns = new Set<string>();
   let personCount = 0;
-  let positionCount = 0;
+  let orderedCount = 0;
 
-  for (const cat of result.categories) {
+  for (const raw of result.categories) {
+    const cat = raw as RawCategory;
     const name = cat.name ?? "";
 
     // Category name checks
@@ -54,14 +75,15 @@ export function validateThemeResult(
     seenNames.add(nameLower);
 
     // Value count
-    if (cat.values.length !== expectedSize) {
+    const values = cat.values ?? [];
+    if (values.length !== expectedSize) {
       errors.push(
-        `Category "${name}" has ${cat.values.length} values, expected ${expectedSize}.`,
+        `Category "${name}" has ${values.length} values, expected ${expectedSize}.`,
       );
     }
 
     // Value checks
-    for (const val of cat.values) {
+    for (const val of values) {
       if (val.trim() === "") {
         errors.push(`Category "${name}" has an empty value.`);
       } else if (val.length > 30) {
@@ -121,9 +143,9 @@ export function validateThemeResult(
       );
     }
 
-    // Position category check
-    if (cat.isPosition) {
-      positionCount++;
+    // Ordered category check
+    if (cat.ordered === true) {
+      orderedCount++;
     }
 
     // numericValues / orderingPhrases (valid on any category)
@@ -193,11 +215,6 @@ export function validateThemeResult(
           `Category "${name}" has positionAdjective but no valueSuffix. They must be set together.`,
         );
       }
-      if (cat.isPosition) {
-        errors.push(
-          `Category "${name}" cannot be both isPosition and positionAdjective. Position categories define the axis; positionAdjective categories describe it.`,
-        );
-      }
     }
 
     // subjectPriority
@@ -219,59 +236,11 @@ export function validateThemeResult(
     );
   }
 
-  if (positionCount > 1) {
+  if (orderedCount === 0) {
     errors.push(
-      "Multiple position categories found. At most one category can have isPosition: true.",
+      "No ordered category found. At least one category must have ordered: true.",
     );
   }
 
-  // Position noun validation
-  if (
-    !Array.isArray(result.positionNoun) ||
-    result.positionNoun.length !== 2 ||
-    typeof result.positionNoun[0] !== "string" ||
-    typeof result.positionNoun[1] !== "string"
-  ) {
-    errors.push("positionNoun must be [singular, plural] string pair.");
-  } else {
-    if (
-      result.positionNoun[0].trim() === "" ||
-      result.positionNoun[1].trim() === ""
-    ) {
-      errors.push("positionNoun strings must not be empty.");
-    }
-  }
-
-  // Position preposition validation
-  if (
-    typeof result.positionPreposition !== "string" ||
-    result.positionPreposition.trim() === ""
-  ) {
-    errors.push("positionPreposition must be a non-empty string.");
-  }
-
-  // No category name/value matches position noun
-  if (Array.isArray(result.positionNoun) && result.positionNoun.length === 2) {
-    const nounLower = result.positionNoun[0].toLowerCase();
-    const nounPluralLower = result.positionNoun[1].toLowerCase();
-    for (const cat of result.categories) {
-      const catName = cat.name ?? "";
-      const catNameLower = catName.toLowerCase();
-      if (catNameLower === nounLower || catNameLower === nounPluralLower) {
-        errors.push(
-          `Category name "${catName}" matches the position noun "${result.positionNoun[0]}".`,
-        );
-      }
-      for (const val of cat.values) {
-        const valLower = val.toLowerCase();
-        if (valLower === nounLower || valLower === nounPluralLower) {
-          errors.push(
-            `Value "${val}" in category "${catName}" matches the position noun "${result.positionNoun[0]}".`,
-          );
-        }
-      }
-    }
-  }
-
   return errors;
 }
diff --git a/packages/logic-grid/README.md b/packages/logic-grid/README.md
index 1c34d2d..ce7caca 100644
--- a/packages/logic-grid/README.md
+++ b/packages/logic-grid/README.md
@@ -68,7 +68,56 @@ const puzzle = generate({
 });
 ```
 
-The `noun` controls how values appear in clue phrases (`"owner"` → "the cat owner", `""` → bare value like "Alice"). The `verb` controls same-house phrasing as `[positive, negative]`. Both are optional — built-in defaults exist for Name, Color, Pet, Drink, Food, Hobby, Music, and Sport.
+The `noun` controls how values appear in clue phrases (`"owner"` → "the cat owner", `""` → bare value like "Alice"). The `verb` controls same-position phrasing as `[positive, negative]`. Both are optional — built-in defaults exist for Name, Color, Pet, Drink, Food, Hobby, Music, and Sport.
+
+### Ordered categories and multi-axis puzzles
+
+Categories with `ordered: true` define a canonical ordering on their values. Comparative constraints (`before`, `left_of`, `next_to`, etc.) reference an ordered category by name via the `axis` field. A puzzle can have multiple ordered axes — e.g. both Year and Return:
+
+```typescript
+const puzzle = generate({
+  size: 4,
+  categoryNames: [
+    { name: "Manager", values: ["Nadine", "Sal", "Terry", "Walter"] },
+    {
+      name: "Year",
+      values: ["1972", "1983", "1997", "2005"],
+      noun: "fund",
+      verb: ["started in", "did not start in"],
+      ordered: true,
+      numericValues: [1972, 1983, 1997, 2005],
+      orderingPhrases: {
+        unit: ["year", "years"],
+        comparators: {
+          before: ["started earlier than", "started later than"],
+        },
+      },
+    },
+    {
+      name: "Return",
+      values: ["6%", "7%", "8%", "9%"],
+      noun: "fund",
+      verb: ["has a return of", "does not have a return of"],
+      ordered: true,
+      orderingPhrases: {
+        unit: ["percentage point", "percentage points"],
+        comparators: {
+          before: ["has a lower return than", "has a higher return than"],
+        },
+      },
+    },
+    {
+      name: "Fund",
+      values: ["Black River", "Citizen Trust", "Pine Bay", "Silver Rock"],
+      noun: "fund",
+      verb: ["runs", "does not run"],
+      valueSuffix: "fund",
+    },
+  ],
+});
+```
+
+When no category has `ordered: true`, a default "House" category is auto-added. `numericValues` enables value-based distance for `exact_distance` ("exactly 25 years from"). `orderingPhrases.comparators` provides per-axis clue phrasing.
 
 ### `solve(constraints, grid)`
 
@@ -102,8 +151,8 @@ Build constraints programmatically:
 
 ```typescript
 import {
-  sameHouse,
-  notSameHouse,
+  samePosition,
+  notSamePosition,
   nextTo,
   notNextTo,
   leftOf,
@@ -116,14 +165,17 @@ import {
 } from "logic-grid";
 
 const constraints = [
-  sameHouse("Red", "Cat"), // Red and Cat are at the same position
-  nextTo("Alice", "Bob"), // Alice is adjacent to Bob
-  leftOf("Blue", "Green"), // Blue is directly left of Green
-  between("Alice", "Bob", "Carol"), // Bob is between Alice and Carol
-  atPosition("Red", 0), // Red is at position 0
+  samePosition("Red", "Cat"), // Red and Cat are at the same position
+  nextTo("Alice", "Bob", "House"), // Alice is adjacent to Bob on the House axis
+  leftOf("Blue", "Green", "House"), // Blue is directly left of Green
+  between("Alice", "Bob", "Carol", "House"), // Bob is between Alice and Carol
+  before("Alice", "Bob", "Year"), // Alice's Year rank < Bob's Year rank
+  atPosition("Red", 0), // Red is at row 0
 ];
 ```
 
+Comparative constraints (`nextTo`, `leftOf`, `between`, `notBetween`, `before`, `notNextTo`, `exactDistance`) take a required `axis` parameter naming an `ordered: true` category.
+
 ### `deduce(constraints, grid)`
 
 Solve a puzzle step-by-step using human-style deduction. Returns each logical step with technique, clue references, and a human-readable explanation. Returns partial results if deduction stalls (e.g. on custom puzzles that require guessing).
@@ -139,7 +191,6 @@ for (const step of result.steps) {
   console.log(step.explanation);
   // "Red is in the first house."
   // "Red and Cat are in the same house: the first house."
-  // "Blue must be in the second house, so no other Color can be there."
 }
 ```
 
@@ -153,53 +204,53 @@ Each step includes:
 
 Techniques:
 
-| Technique        | Description                                                    |
-| ---------------- | -------------------------------------------------------------- |
-| `direct`         | Value forced to a specific position by `at_position`           |
-| `elimination`    | Position ruled out by `not_at_position`                        |
-| `same_house`     | Two values share possible positions — intersect them           |
-| `not_same_house` | Pinned value excludes its position from the other              |
-| `next_to`        | Positions incompatible with adjacency are removed              |
-| `not_next_to`    | Pinned value excludes its neighbors from the other             |
-| `left_of`        | Value directly left of another — constrain both                |
-| `before`         | Value somewhere left of another — constrain range              |
-| `between`        | Middle must lie strictly between two outers                    |
-| `not_between`    | Middle cannot lie between two pinned outers                    |
-| `exact_distance` | Two values must be exactly N positions apart                   |
-| `naked_single`   | One value is the only candidate for a position in its category |
-| `hidden_single`  | One position is the only candidate for a value in its category |
-| `naked_pair`     | Two values share the same two positions — exclude others       |
-| `naked_triple`   | Three values share three positions — exclude others            |
-| `hidden_pair`    | Two positions are exclusively reachable by two values          |
-| `hidden_triple`  | Three positions are exclusively reachable by three values      |
-| `contradiction`  | Placing a value at a position leads to an impossible state     |
+| Technique           | Description                                                    |
+| ------------------- | -------------------------------------------------------------- |
+| `direct`            | Value forced to a specific position by `at_position`           |
+| `elimination`       | Position ruled out by `not_at_position`                        |
+| `same_position`     | Two values share possible positions — intersect them           |
+| `not_same_position` | Pinned value excludes its position from the other              |
+| `next_to`           | Positions incompatible with adjacency are removed              |
+| `not_next_to`       | Pinned value excludes its neighbors from the other             |
+| `left_of`           | Value directly left of another — constrain both                |
+| `before`            | Value somewhere left of another — constrain range              |
+| `between`           | Middle must lie strictly between two outers                    |
+| `not_between`       | Middle cannot lie between two pinned outers                    |
+| `exact_distance`    | Two values must be exactly N apart on the axis                 |
+| `naked_single`      | One value is the only candidate for a position in its category |
+| `hidden_single`     | One position is the only candidate for a value in its category |
+| `naked_pair`        | Two values share the same two positions — exclude others       |
+| `naked_triple`      | Three values share three positions — exclude others            |
+| `hidden_pair`       | Two positions are exclusively reachable by two values          |
+| `hidden_triple`     | Three positions are exclusively reachable by three values      |
+| `contradiction`     | Placing a value at a position leads to an impossible state     |
 
 ### `renderClue(constraint, grid)`
 
-Convert a constraint to a human-readable clue. Produces natural English phrasing based on category names (e.g. "Alice owns the dog" for Name+Pet, "The red house has a cat" for Color+Pet).
+Convert a constraint to a human-readable clue. Produces natural English phrasing based on category names and per-axis `orderingPhrases`.
 
 ```typescript
-import { renderClue, sameHouse } from "logic-grid";
+import { renderClue, samePosition } from "logic-grid";
 
-const clue = renderClue(sameHouse("Red", "Cat"), grid);
-// { constraint: ..., text: "The red house has a cat." }
+const clue = renderClue(samePosition("Red", "Cat"), grid);
+// { constraint: ..., text: "The cat owner lives in the red house." }
 ```
 
 ## Constraint Types
 
-| Type              | Meaning                                      |
-| ----------------- | -------------------------------------------- |
-| `same_house`      | Two values are at the same position          |
-| `not_same_house`  | Two values are at different positions        |
-| `next_to`         | Two values are at adjacent positions         |
-| `not_next_to`     | Two values are not adjacent                  |
-| `left_of`         | First value is directly left of second       |
-| `between`         | Middle value is somewhere between two outers |
-| `not_between`     | Middle value is not between two outers       |
-| `before`          | First value is somewhere left of second      |
-| `exact_distance`  | Two values are exactly N positions apart     |
-| `at_position`     | Value is at a specific position (0-indexed)  |
-| `not_at_position` | Value is not at a specific position          |
+| Type                | Meaning                                                |
+| ------------------- | ------------------------------------------------------ |
+| `same_position`     | Two values are at the same position                    |
+| `not_same_position` | Two values are at different positions                  |
+| `next_to`           | Two values are rank-adjacent on the named axis         |
+| `not_next_to`       | Two values are not rank-adjacent                       |
+| `left_of`           | First value's rank is exactly one less than second's   |
+| `between`           | Middle value's rank is strictly between two outers     |
+| `not_between`       | Middle value's rank is not between two outers          |
+| `before`            | First value's rank is strictly less than second's      |
+| `exact_distance`    | Two values are exactly N apart (rank steps or numeric) |
+| `at_position`       | Value is at a specific row (0-indexed)                 |
+| `not_at_position`   | Value is not at a specific row                         |
 
 ## Types
 
@@ -209,14 +260,21 @@ type Difficulty = "easy" | "medium" | "hard" | "expert";
 interface Grid {
   size: number;
   categories: Category[];
+  displayAxis?: string; // presentation hint: which ordered category for column headers
 }
 
-interface Category {
+type Category = CategoryCore & OrderednessFields & ValueSuffixFields;
+
+// See types.ts for the full discriminated union. Key fields:
+interface CategoryCore {
   name: string;
   values: string[];
-  noun?: string; // label noun for clues
-  verb?: [string, string]; // [positive, negative] verb phrases
+  noun?: string;
+  verb?: [string, string];
+  subjectPriority?: number;
 }
+// ordered: true requires orderingPhrases with all 7 comparators.
+// valueSuffix enables positionAdjective.
 
 type Solution = Assignment[]; // one per category
 type Assignment = Record<string, number>; // value → position (0-indexed)
@@ -229,11 +287,11 @@ interface Clue {
 
 ## How It Works
 
-1. **SAT encoding** — each puzzle is encoded as a boolean satisfiability problem (CNF). Variable `x(v, p)` represents "value v is at position p". At-least-one and at-most-one constraints ensure valid assignments.
+1. **SAT encoding** — each puzzle is encoded as a boolean satisfiability problem (CNF). Variable `x(v, p)` represents "value v is at position p". At-least-one and at-most-one constraints ensure valid assignments. Comparative constraints on non-identity-pinned axes use rank-forbidding clauses.
 
 2. **DPLL solver** — a minimal DPLL SAT solver with watched literals and flat `Int32Array` storage. No external dependencies.
 
-3. **Generation** — a random valid solution is generated, all true constraints are enumerated, then a minimal diverse subset is selected through constructive round-robin minimization: constraints are added one per type in rotation until uniqueness is achieved, then redundant ones are trimmed. An incremental solver with assumption literals avoids rebuilding the solver for each uniqueness check.
+3. **Generation** — a random valid solution is generated, all true constraints are enumerated per ordered axis, then a minimal diverse subset is selected through constructive round-robin minimization: constraints are added one per type in rotation until uniqueness is achieved, then redundant ones are trimmed. An incremental solver with assumption literals avoids rebuilding the solver for each uniqueness check.
 
 4. **Difficulty** — classified by constraint type complexity and whether the puzzle is solvable by direct elimination alone.
 
diff --git a/packages/logic-grid/src/__snapshots__/index.test.ts.snap b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
index d1f43c1..dd96ecc 100644
--- a/packages/logic-grid/src/__snapshots__/index.test.ts.snap
+++ b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
@@ -2,17 +2,15 @@
 
 exports[`public API integration > generate with custom noun/verb produces correct clues 1`] = `
 [
-  "Kai does not live next to the italian speaker.",
-  "Nora speaks spanish.",
-  "Kai does not grow the lily.",
-  "The tulip grower lives next to the piano player.",
-  "The rose grower lives somewhere between Luna and the piano player.",
-  "Theo speaks italian.",
-  "The lily grower lives in the fourth house.",
-  "The german speaker lives directly right of the rose grower.",
-  "Nora grows the tulip.",
-  "The violin player does not live in the third house.",
-  "The italian speaker lives in the first house.",
+  "Luna speaks german.",
+  "The tulip grower lives directly right of the piano player.",
+  "Nora lives next to the italian speaker.",
+  "Kai does not live in the first house.",
   "The guitar player grows the tulip.",
+  "Theo grows the daisy.",
+  "Luna lives somewhere right of the french speaker.",
+  "Kai grows the rose.",
+  "Luna lives directly right of the drums player.",
+  "The french speaker lives in the third house.",
 ]
 `;
diff --git a/packages/logic-grid/src/axis.test.ts b/packages/logic-grid/src/axis.test.ts
new file mode 100644
index 0000000..48f454a
--- /dev/null
+++ b/packages/logic-grid/src/axis.test.ts
@@ -0,0 +1,140 @@
+import { describe, it, expect } from "vitest";
+import {
+  orderedCategories,
+  resolveAxis,
+  axisRank,
+  displayAxisCategory,
+  validateConstraints,
+} from "./axis";
+import { makeGrid, TEST_COMPARATORS } from "./test-helpers";
+
+const grid = makeGrid({
+  size: 3,
+  categories: [
+    { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+    {
+      name: "Year",
+      values: ["2020", "2021", "2022"],
+      noun: "fund",
+      verb: ["started in", "did not start in"],
+      ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
+    },
+    {
+      name: "Return",
+      values: ["5%", "6%", "7%"],
+      noun: "fund",
+      verb: ["has a return of", "does not have a return of"],
+      ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
+    },
+  ],
+});
+
+describe("orderedCategories", () => {
+  it("returns only ordered categories", () => {
+    const ordered = orderedCategories(grid);
+    expect(ordered.map((c) => c.name)).toEqual(["Year", "Return"]);
+  });
+});
+
+describe("resolveAxis", () => {
+  it("returns the named ordered category", () => {
+    expect(resolveAxis(grid, "Year").name).toBe("Year");
+    expect(resolveAxis(grid, "Return").name).toBe("Return");
+  });
+
+  it("throws for unknown category name", () => {
+    expect(() => resolveAxis(grid, "Nope")).toThrow("Unknown axis");
+  });
+
+  it("throws for non-ordered category", () => {
+    expect(() => resolveAxis(grid, "Name")).toThrow(
+      "must reference an ordered category",
+    );
+  });
+});
+
+describe("axisRank", () => {
+  it("returns the index of the value in the ordered category", () => {
+    const year = resolveAxis(grid, "Year");
+    expect(axisRank(year, "2020")).toBe(0);
+    expect(axisRank(year, "2022")).toBe(2);
+  });
+
+  it("throws for non-ordered category", () => {
+    const name = grid.categories.find((c) => c.name === "Name")!;
+    expect(() => axisRank(name, "Alice")).toThrow("is not ordered");
+  });
+
+  it("throws for value not in the category", () => {
+    const year = resolveAxis(grid, "Year");
+    expect(() => axisRank(year, "Alice")).toThrow("is not a member");
+  });
+});
+
+describe("displayAxisCategory", () => {
+  it("returns first ordered category by default", () => {
+    expect(displayAxisCategory(grid).name).toBe("Year");
+  });
+
+  it("respects grid.displayAxis when set", () => {
+    const g = { ...grid, displayAxis: "Return" };
+    expect(displayAxisCategory(g).name).toBe("Return");
+  });
+
+  it("throws when no ordered category exists", () => {
+    const noOrdered = makeGrid({
+      size: 3,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+      ],
+    });
+    // makeGrid auto-adds House, so strip it for this test
+    const bare = {
+      ...noOrdered,
+      categories: noOrdered.categories.filter((c) => c.ordered !== true),
+    };
+    expect(() => displayAxisCategory(bare)).toThrow(
+      "no ordered category to use as display axis",
+    );
+  });
+});
+
+describe("validateConstraints", () => {
+  it("passes for valid constraints", () => {
+    expect(() =>
+      validateConstraints(
+        [{ type: "before", a: "Alice", b: "Bob", axis: "Year" }],
+        grid,
+      ),
+    ).not.toThrow();
+  });
+
+  it("throws for constraint referencing unknown axis", () => {
+    expect(() =>
+      validateConstraints(
+        [{ type: "before", a: "Alice", b: "Bob", axis: "Nope" }],
+        grid,
+      ),
+    ).toThrow("Unknown axis");
+  });
+
+  it("throws for constraint referencing non-ordered axis", () => {
+    expect(() =>
+      validateConstraints(
+        [{ type: "next_to", a: "Alice", b: "Bob", axis: "Name" }],
+        grid,
+      ),
+    ).toThrow("must reference an ordered category");
+  });
+
+  it("ignores non-axis constraints", () => {
+    expect(() =>
+      validateConstraints(
+        [{ type: "same_position", a: "Alice", b: "Bob" }],
+        grid,
+      ),
+    ).not.toThrow();
+  });
+});
diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
new file mode 100644
index 0000000..56d1bb6
--- /dev/null
+++ b/packages/logic-grid/src/axis.ts
@@ -0,0 +1,82 @@
+import type { Category, Constraint, Grid, OrderedCategory } from "./types";
+
+/** Type predicate: narrows Category to OrderedCategory. */
+export function isOrdered(c: Category): c is OrderedCategory {
+  return c.ordered === true;
+}
+
+/**
+ * Return the list of `ordered: true` categories in declaration order.
+ * These are the axes available to comparative constraints.
+ * Returns an empty array (never throws) if no ordered category exists.
+ */
+export function orderedCategories(grid: Grid): OrderedCategory[] {
+  return grid.categories.filter(isOrdered);
+}
+
+/**
+ * Resolve an axis name to its ordered category. Throws if the name does not
+ * match any category or if the matching category is not ordered.
+ */
+export function resolveAxis(grid: Grid, axisName: string): OrderedCategory {
+  const cat = grid.categories.find((c) => c.name === axisName);
+  if (!cat) {
+    throw new RangeError(`Unknown axis: "${axisName}"`);
+  }
+  if (!isOrdered(cat)) {
+    throw new RangeError(
+      `Axis "${axisName}" must reference an ordered category`,
+    );
+  }
+  return cat;
+}
+
+/**
+ * Rank of `value` on the given ordered category. Throws if the category is
+ * not ordered or the value does not belong to it.
+ */
+export function axisRank(category: Category, value: string): number {
+  if (category.ordered !== true) {
+    throw new RangeError(
+      `Category "${category.name}" is not ordered; axisRank undefined`,
+    );
+  }
+  const idx = category.values.indexOf(value);
+  if (idx === -1) {
+    throw new RangeError(
+      `Value "${value}" is not a member of category "${category.name}"`,
+    );
+  }
+  return idx;
+}
+
+/**
+ * Return the presentation display-anchor category for the grid. Reads
+ * `grid.displayAxis` when set; otherwise returns the first ordered category.
+ * Throws if no ordered category exists.
+ */
+export function displayAxisCategory(grid: Grid): OrderedCategory {
+  if (grid.displayAxis !== undefined) {
+    return resolveAxis(grid, grid.displayAxis);
+  }
+  const first = orderedCategories(grid)[0];
+  if (!first) {
+    throw new RangeError("Grid has no ordered category to use as display axis");
+  }
+  return first;
+}
+
+/**
+ * Validate that every comparative constraint in `constraints` references an
+ * ordered category that exists in the grid. Throws on the first violation.
+ */
+export function validateConstraints(
+  constraints: Constraint[],
+  grid: Grid,
+): void {
+  for (const c of constraints) {
+    if ("axis" in c && typeof c.axis === "string") {
+      resolveAxis(grid, c.axis);
+    }
+  }
+}
diff --git a/packages/logic-grid/src/clues/constraints.test.ts b/packages/logic-grid/src/clues/constraints.test.ts
index 5150dc6..57640f8 100644
--- a/packages/logic-grid/src/clues/constraints.test.ts
+++ b/packages/logic-grid/src/clues/constraints.test.ts
@@ -31,69 +31,76 @@ describe("constraint factories", () => {
   });
 
   it("nextTo", () => {
-    expect(nextTo("Red", "Cat")).toEqual({
+    expect(nextTo("Red", "Cat", "House")).toEqual({
       type: "next_to",
       a: "Red",
       b: "Cat",
+      axis: "House",
     });
   });
 
   it("notNextTo", () => {
-    expect(notNextTo("Red", "Cat")).toEqual({
+    expect(notNextTo("Red", "Cat", "House")).toEqual({
       type: "not_next_to",
       a: "Red",
       b: "Cat",
+      axis: "House",
     });
   });
 
   it("leftOf", () => {
-    expect(leftOf("Blue", "Green")).toEqual({
+    expect(leftOf("Blue", "Green", "House")).toEqual({
       type: "left_of",
       a: "Blue",
       b: "Green",
+      axis: "House",
     });
   });
 
   it("between", () => {
-    expect(between("Red", "Cat", "Blue")).toEqual({
+    expect(between("Red", "Cat", "Blue", "House")).toEqual({
       type: "between",
       outer1: "Red",
       middle: "Cat",
       outer2: "Blue",
-    });
-  });
-
-  it("atPosition", () => {
-    expect(atPosition("Red", 0)).toEqual({
-      type: "at_position",
-      value: "Red",
-      position: 0,
+      axis: "House",
     });
   });
 
   it("notBetween", () => {
-    expect(notBetween("Red", "Cat", "Blue")).toEqual({
+    expect(notBetween("Red", "Cat", "Blue", "House")).toEqual({
       type: "not_between",
       outer1: "Red",
       middle: "Cat",
       outer2: "Blue",
+      axis: "House",
     });
   });
 
   it("before", () => {
-    expect(before("Blue", "Green")).toEqual({
+    expect(before("Blue", "Green", "House")).toEqual({
       type: "before",
       a: "Blue",
       b: "Green",
+      axis: "House",
     });
   });
 
   it("exactDistance", () => {
-    expect(exactDistance("Red", "Cat", 2)).toEqual({
+    expect(exactDistance("Red", "Cat", 2, "House")).toEqual({
       type: "exact_distance",
       a: "Red",
       b: "Cat",
       distance: 2,
+      axis: "House",
+    });
+  });
+
+  it("atPosition", () => {
+    expect(atPosition("Red", 0)).toEqual({
+      type: "at_position",
+      value: "Red",
+      position: 0,
     });
   });
 
diff --git a/packages/logic-grid/src/clues/constraints.ts b/packages/logic-grid/src/clues/constraints.ts
index f65b7b7..520e9ba 100644
--- a/packages/logic-grid/src/clues/constraints.ts
+++ b/packages/logic-grid/src/clues/constraints.ts
@@ -10,59 +10,62 @@ export function notSamePosition(a: string, b: string): Constraint {
   return { type: "not_same_position", a, b };
 }
 
-/** `a` and `b` are at adjacent positions. */
-export function nextTo(a: string, b: string): Constraint {
-  return { type: "next_to", a, b };
+/** `a` and `b` have adjacent ranks on `axis`. */
+export function nextTo(a: string, b: string, axis: string): Constraint {
+  return { type: "next_to", a, b, axis };
 }
 
-/** `a` and `b` are not adjacent. */
-export function notNextTo(a: string, b: string): Constraint {
-  return { type: "not_next_to", a, b };
+/** `a` and `b` do not have adjacent ranks on `axis`. */
+export function notNextTo(a: string, b: string, axis: string): Constraint {
+  return { type: "not_next_to", a, b, axis };
 }
 
-/** `a` is immediately left of `b` (position of `a` = position of `b` - 1). */
-export function leftOf(a: string, b: string): Constraint {
-  return { type: "left_of", a, b };
+/** `a`'s rank on `axis` is exactly one less than `b`'s. */
+export function leftOf(a: string, b: string, axis: string): Constraint {
+  return { type: "left_of", a, b, axis };
 }
 
-/** `middle` is strictly between `outer1` and `outer2`. */
+/** `middle`'s rank on `axis` is strictly between `outer1` and `outer2`. */
 export function between(
   outer1: string,
   middle: string,
   outer2: string,
+  axis: string,
 ): Constraint {
-  return { type: "between", outer1, middle, outer2 };
+  return { type: "between", outer1, middle, outer2, axis };
 }
 
-/** `middle` is NOT between `outer1` and `outer2`. */
+/** `middle`'s rank on `axis` is NOT strictly between `outer1` and `outer2`. */
 export function notBetween(
   outer1: string,
   middle: string,
   outer2: string,
+  axis: string,
 ): Constraint {
-  return { type: "not_between", outer1, middle, outer2 };
+  return { type: "not_between", outer1, middle, outer2, axis };
 }
 
-/** `a` is somewhere to the left of `b` (not necessarily adjacent). */
-export function before(a: string, b: string): Constraint {
-  return { type: "before", a, b };
+/** `a`'s rank on `axis` is strictly less than `b`'s. */
+export function before(a: string, b: string, axis: string): Constraint {
+  return { type: "before", a, b, axis };
 }
 
-/** `a` and `b` are exactly `distance` positions apart. */
+/** `a` and `b` are exactly `distance` apart on `axis` (rank steps, or numericValues units when present). */
 export function exactDistance(
   a: string,
   b: string,
   distance: number,
+  axis: string,
 ): Constraint {
-  return { type: "exact_distance", a, b, distance };
+  return { type: "exact_distance", a, b, distance, axis };
 }
 
-/** `value` is at the given 0-indexed position. */
+/** `value` is at the given 0-indexed row position. */
 export function atPosition(value: string, position: number): Constraint {
   return { type: "at_position", value, position };
 }
 
-/** `value` is not at the given 0-indexed position. */
+/** `value` is not at the given 0-indexed row position. */
 export function notAtPosition(value: string, position: number): Constraint {
   return { type: "not_at_position", value, position };
 }
diff --git a/packages/logic-grid/src/clues/templates.test.ts b/packages/logic-grid/src/clues/templates.test.ts
index 4df5f2e..e4da40d 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -1,17 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { renderClue } from "./templates";
-import { DEFAULT_CONFIG } from "../default-config";
 import { makeGrid } from "../test-helpers";
-import type { Grid, SpatialWords } from "../types";
-
-const POSITIONAL_WORDS: SpatialWords = {
-  verb: ["is", "is not"],
-  adjacency: "adjacent to",
-  direction: ["before", "after"],
-  between: "somewhere between",
-  atPosition: ["is at", "is not at"],
-  cardinals: ["zero", "one", "two", "three", "four", "five", "six", "seven"],
-};
+import type { Grid } from "../types";
 
 const grid = makeGrid({
   size: 3,
@@ -46,11 +36,9 @@ const grid = makeGrid({
       subjectPriority: 1,
     },
   ],
-  spatialWords: DEFAULT_CONFIG.spatialWords,
-  positionLabels: ["the first house", "the second house", "the third house"],
 });
 
-describe("renderClue", () => {
+describe("renderClue — classic same_position paths", () => {
   it("same_position: color + pet", () => {
     const clue = renderClue(
       { type: "same_position", a: "Red", b: "Cat" },
@@ -83,113 +71,129 @@ describe("renderClue", () => {
     expect(clue.text).toBe("Carol drinks tea.");
   });
 
-  it("same_position: pet + drink", () => {
+  it("not_same_position: name + pet", () => {
     const clue = renderClue(
-      { type: "same_position", a: "Cat", b: "Coffee" },
+      { type: "not_same_position", a: "Alice", b: "Dog" },
       grid,
     );
-    expect(clue.text).toBe("The cat owner drinks coffee.");
+    expect(clue.text).toBe("Alice does not own the dog.");
   });
 
-  it("not_same_position: name + pet", () => {
+  it("not_same_position: color + pet", () => {
     const clue = renderClue(
-      { type: "not_same_position", a: "Alice", b: "Dog" },
+      { type: "not_same_position", a: "Red", b: "Cat" },
       grid,
     );
-    expect(clue.text).toBe("Alice does not own the dog.");
+    expect(clue.text).toBe("The cat owner does not live in the red house.");
   });
 
-  it("not_same_position: name + color", () => {
+  it("subject priority swap", () => {
     const clue = renderClue(
-      { type: "not_same_position", a: "Bob", b: "Red" },
+      { type: "same_position", a: "Cat", b: "Alice" },
       grid,
     );
-    expect(clue.text).toBe("Bob does not live in the red house.");
+    expect(clue.text).toBe("Alice owns the cat.");
   });
 
-  it("not_same_position: color + pet", () => {
+  it("preserves constraint in returned clue", () => {
+    const constraint = { type: "same_position" as const, a: "Red", b: "Cat" };
+    const clue = renderClue(constraint, grid);
+    expect(clue.constraint).toBe(constraint);
+  });
+
+  it("throws on unknown value", () => {
+    expect(() =>
+      renderClue({ type: "same_position", a: "Unknown", b: "Cat" }, grid),
+    ).toThrow("Unknown value: Unknown");
+  });
+});
+
+describe("at_position / not_at_position", () => {
+  it("at_position renders via position label from first ordered category", () => {
     const clue = renderClue(
-      { type: "not_same_position", a: "Red", b: "Cat" },
+      { type: "at_position", value: "Alice", position: 0 },
       grid,
     );
-    expect(clue.text).toBe("The cat owner does not live in the red house.");
+    expect(clue.text).toBe("Alice lives in the first house.");
   });
 
-  it("not_same_position: name + drink", () => {
+  it("not_at_position uses positionAdjective for Color+House", () => {
     const clue = renderClue(
-      { type: "not_same_position", a: "Alice", b: "Tea" },
+      { type: "not_at_position", value: "Red", position: 2 },
       grid,
     );
-    expect(clue.text).toBe("Alice does not drink tea.");
+    expect(clue.text).toBe("The third house is not red.");
   });
 
-  it("not_same_position: color + drink", () => {
+  it("at_position uses positionAdjective for Color+House", () => {
     const clue = renderClue(
-      { type: "not_same_position", a: "Blue", b: "Coffee" },
+      { type: "at_position", value: "Red", position: 1 },
       grid,
     );
-    expect(clue.text).toBe(
-      "The coffee drinker does not live in the blue house.",
-    );
+    expect(clue.text).toBe("The second house is red.");
   });
+});
 
-  it("not_same_position: pet + drink", () => {
-    // Equal priority (Pet 1, Drink 1) → hash tiebreaker picks subject
+describe("positionAdjective + ordered rendering rule", () => {
+  // The auto-added House category is ordered; Color has positionAdjective.
+  // same_position(Red, "first") must render as "The first house is red."
+  it("recovers Color+House 'is red' phrasing via same_position", () => {
     const clue = renderClue(
-      { type: "not_same_position", a: "Dog", b: "Water" },
+      { type: "same_position", a: "Red", b: "first" },
       grid,
     );
-    expect(clue.text).toBe("The water drinker does not own the dog.");
+    expect(clue.text).toBe("The first house is red.");
   });
 
-  it("same_position tiebreak is deterministic across pairs", () => {
-    // Equal priority (both Pet+Drink, priority 1). Hash gives consistent
-    // results per value pair, but different pairs may get different subjects.
-    const clueA = renderClue(
-      { type: "same_position", a: "Dog", b: "Water" },
+  it("negated variant renders 'is not red'", () => {
+    const clue = renderClue(
+      { type: "not_same_position", a: "Red", b: "second" },
       grid,
     );
-    const clueB = renderClue(
-      { type: "same_position", a: "Cat", b: "Tea" },
+    expect(clue.text).toBe("The second house is not red.");
+  });
+
+  it("works with house value as constraint.a", () => {
+    const clue = renderClue(
+      { type: "same_position", a: "third", b: "Blue" },
       grid,
     );
-    // Both should be valid grammatical sentences
-    expect(clueA.text).toMatch(
-      /^(The dog owner drinks water|The water drinker owns the dog)\.$/,
-    );
-    expect(clueB.text).toMatch(
-      /^(The cat owner drinks tea|The tea drinker owns the cat)\.$/,
-    );
-    // Same input → same output (deterministic)
-    const clueA2 = renderClue(
-      { type: "same_position", a: "Dog", b: "Water" },
+    expect(clue.text).toBe("The third house is blue.");
+  });
+
+  it("Name + House falls through to normal same_position path", () => {
+    const clue = renderClue(
+      { type: "same_position", a: "Alice", b: "first" },
       grid,
     );
-    expect(clueA2.text).toBe(clueA.text);
+    expect(clue.text).toBe("Alice lives in the first house.");
   });
+});
 
+describe("renderClue — comparatives on House axis", () => {
   it("next_to", () => {
-    const clue = renderClue({ type: "next_to", a: "Blue", b: "Cat" }, grid);
+    const clue = renderClue(
+      { type: "next_to", a: "Blue", b: "Cat", axis: "House" },
+      grid,
+    );
     expect(clue.text).toBe("The cat owner lives next to the blue house.");
   });
 
   it("not_next_to", () => {
-    const clue = renderClue({ type: "not_next_to", a: "Tea", b: "Dog" }, grid);
+    const clue = renderClue(
+      { type: "not_next_to", a: "Tea", b: "Dog", axis: "House" },
+      grid,
+    );
     expect(clue.text).toBe(
       "The tea drinker does not live next to the dog owner.",
     );
   });
 
-  it("not_next_to: color + pet", () => {
-    const clue = renderClue({ type: "not_next_to", a: "Red", b: "Cat" }, grid);
-    expect(clue.text).toBe(
-      "The cat owner does not live next to the red house.",
+  it("left_of", () => {
+    const clue = renderClue(
+      { type: "left_of", a: "Blue", b: "Green", axis: "House" },
+      grid,
     );
-  });
-
-  it("left_of renders as left or right", () => {
-    const clue = renderClue({ type: "left_of", a: "Blue", b: "Green" }, grid);
-    // Deterministic per constraint — could be either phrasing
     expect(
       clue.text === "The blue house lives directly left of the green house." ||
         clue.text === "The green house lives directly right of the blue house.",
@@ -198,7 +202,13 @@ describe("renderClue", () => {
 
   it("between", () => {
     const clue = renderClue(
-      { type: "between", outer1: "Red", middle: "Cat", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Cat",
+        outer2: "Blue",
+        axis: "House",
+      },
       grid,
     );
     expect(clue.text).toBe(
@@ -206,22 +216,6 @@ describe("renderClue", () => {
     );
   });
 
-  it("at_position", () => {
-    const clue = renderClue(
-      { type: "at_position", value: "Tea", position: 0 },
-      grid,
-    );
-    expect(clue.text).toBe("The tea drinker lives in the first house.");
-  });
-
-  it("not_at_position", () => {
-    const clue = renderClue(
-      { type: "not_at_position", value: "Red", position: 2 },
-      grid,
-    );
-    expect(clue.text).toBe("The third house is not red.");
-  });
-
   it("not_between", () => {
     const clue = renderClue(
       {
@@ -229,6 +223,7 @@ describe("renderClue", () => {
         outer1: "Red",
         middle: "Cat",
         outer2: "Blue",
+        axis: "House",
       },
       grid,
     );
@@ -237,59 +232,40 @@ describe("renderClue", () => {
     );
   });
 
-  it("not_between: house noun as middle", () => {
+  it("before", () => {
     const clue = renderClue(
-      { type: "not_between", outer1: "Alice", middle: "Red", outer2: "Cat" },
+      { type: "before", a: "Alice", b: "Cat", axis: "House" },
       grid,
     );
-    expect(clue.text).toBe(
-      "The red house is not somewhere between Alice and the cat owner.",
-    );
-  });
-
-  it("before", () => {
-    const clue = renderClue({ type: "before", a: "Alice", b: "Cat" }, grid);
     expect(clue.text).toMatch(/somewhere (left|right) of/);
   });
 
-  it("exact_distance", () => {
+  it("exact_distance plural", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Cat",
+        distance: 2,
+        axis: "House",
+      },
       grid,
     );
-    expect(clue.text).toBe(
-      "Alice lives exactly two houses from the cat owner.",
-    );
+    expect(clue.text).toBe("Alice lives exactly 2 houses from the cat owner.");
   });
 
   it("exact_distance singular", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 1 },
-      grid,
-    );
-    expect(clue.text).toBe("Alice lives exactly one house from the cat owner.");
-  });
-
-  it("throws on unknown value", () => {
-    expect(() =>
-      renderClue({ type: "same_position", a: "Unknown", b: "Cat" }, grid),
-    ).toThrow("Unknown value: Unknown");
-  });
-
-  it("swaps subject/object when b has higher priority", () => {
-    // Cat (owner, priority 1) as a, Alice (person, priority 2) as b
-    // Should swap so Alice becomes the subject
-    const clue = renderClue(
-      { type: "same_position", a: "Cat", b: "Alice" },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Cat",
+        distance: 1,
+        axis: "House",
+      },
       grid,
     );
-    expect(clue.text).toBe("Alice owns the cat.");
-  });
-
-  it("preserves constraint in returned clue", () => {
-    const constraint = { type: "same_position" as const, a: "Red", b: "Cat" };
-    const clue = renderClue(constraint, grid);
-    expect(clue.constraint).toBe(constraint);
+    expect(clue.text).toBe("Alice lives exactly 1 house from the cat owner.");
   });
 });
 
@@ -310,8 +286,6 @@ describe("custom category noun/verb", () => {
         noun: "lover",
       },
     ],
-    spatialWords: DEFAULT_CONFIG.spatialWords,
-    positionLabels: ["the first house", "the second house", "the third house"],
   });
 
   it("same_position with custom verb", () => {
@@ -322,90 +296,43 @@ describe("custom category noun/verb", () => {
     expect(clue.text).toBe("Alice drives the toyota.");
   });
 
-  it("not_same_position with custom verb", () => {
-    const clue = renderClue(
-      { type: "not_same_position", a: "Alice", b: "BMW" },
-      customGrid,
-    );
-    expect(clue.text).toBe("Alice does not drive the bmw.");
-  });
-
-  it("custom noun in label", () => {
-    const clue = renderClue(
-      { type: "next_to", a: "Toyota", b: "Apple" },
-      customGrid,
-    );
-    expect(clue.text).toBe("The toyota driver lives next to the apple lover.");
-  });
-
   it("throws when object category has no verb", () => {
     expect(() =>
       renderClue({ type: "same_position", a: "Alice", b: "Apple" }, customGrid),
     ).toThrow('category "Fruit" has no verb');
   });
-
-  it("empty-string noun renders bare value", () => {
-    const bareGrid = makeGrid({
-      size: 3,
-      categories: [
-        {
-          name: "Player",
-          values: ["Alice", "Bob", "Carol"],
-          noun: "",
-        },
-        {
-          name: "Color",
-          values: ["Red", "Blue", "Green"],
-          noun: "house",
-          verb: ["lives in the", "does not live in the"],
-          subjectPriority: -1,
-          valueSuffix: "house",
-          positionAdjective: ["is", "is not"],
-        },
-      ],
-      spatialWords: DEFAULT_CONFIG.spatialWords,
-      positionLabels: [
-        "the first house",
-        "the second house",
-        "the third house",
-      ],
-    });
-    const clue = renderClue(
-      { type: "same_position", a: "Alice", b: "Red" },
-      bareGrid,
-    );
-    expect(clue.text).toBe("Alice lives in the red house.");
-  });
-
-  it("falls back to defaults when no custom noun/verb", () => {
-    // Standard grid with no custom fields — should work as before
-    const clue = renderClue(
-      { type: "same_position", a: "Alice", b: "Red" },
-      grid,
-    );
-    expect(clue.text).toBe("Alice lives in the red house.");
-  });
 });
 
-describe("custom positionNoun / positionPreposition", () => {
-  const seatGrid = makeGrid({
+describe("per-axis comparator overrides on House", () => {
+  // Build a grid with custom House comparators.
+  const withComparators = makeGrid({
     size: 3,
     categories: [
+      {
+        name: "House",
+        noun: "house",
+        verb: ["lives in the", "does not live in the"],
+        valueSuffix: "house",
+        ordered: true,
+        values: ["first", "second", "third"],
+        orderingPhrases: {
+          comparators: {
+            before: ["comes earlier than", "comes later than"],
+            left_of: ["is directly before", "is directly after"],
+            next_to: "is adjacent to",
+            not_next_to: "is not adjacent to",
+            between: "is between",
+            not_between: "is not between",
+            exact_distance: "is exactly",
+          },
+        },
+      },
       {
         name: "Name",
         values: ["Alice", "Bob", "Carol"],
         noun: "",
         subjectPriority: 2,
       },
-      {
-        name: "Color",
-        values: ["Red", "Blue", "Green"],
-        noun: "house",
-        verb: ["lives at the", "does not live at the"],
-        subjectPriority: -1,
-        valueSuffix: "seat",
-        positionAdjective: ["is", "is not"],
-      },
       {
         name: "Pet",
         values: ["Cat", "Dog", "Fish"],
@@ -413,402 +340,266 @@ describe("custom positionNoun / positionPreposition", () => {
         verb: ["owns the", "does not own the"],
         subjectPriority: 1,
       },
-      {
-        name: "Drink",
-        values: ["Tea", "Coffee", "Water"],
-        noun: "drinker",
-        verb: ["drinks", "does not drink"],
-        subjectPriority: 1,
-      },
     ],
-    positionNoun: ["seat", "seats"],
-    positionPreposition: "at",
-    spatialWords: {
-      ...DEFAULT_CONFIG.spatialWords,
-      atPosition: ["lives at", "does not live at"],
-    },
-    positionLabels: ["the first seat", "the second seat", "the third seat"],
   });
 
-  it("at_position uses custom noun and preposition", () => {
+  it("left_of uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "at_position", value: "Tea", position: 0 },
-      seatGrid,
+      { type: "left_of", a: "Alice", b: "Bob", axis: "House" },
+      withComparators,
     );
-    expect(clue.text).toBe("The tea drinker lives at the first seat.");
+    expect(clue.text).toBe("Bob is directly after Alice.");
   });
 
-  it("at_position with color uses custom noun", () => {
+  it("before uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "at_position", value: "Red", position: 2 },
-      seatGrid,
+      { type: "before", a: "Alice", b: "Bob", axis: "House" },
+      withComparators,
     );
-    expect(clue.text).toBe("The third seat is red.");
+    expect(clue.text).toBe("Bob comes later than Alice.");
   });
 
-  it("not_at_position uses custom noun and preposition", () => {
+  it("next_to uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "not_at_position", value: "Alice", position: 1 },
-      seatGrid,
+      { type: "next_to", a: "Alice", b: "Bob", axis: "House" },
+      withComparators,
     );
-    expect(clue.text).toBe("Alice does not live at the second seat.");
-  });
-
-  it("not_at_position with color uses custom noun", () => {
-    const clue = renderClue(
-      { type: "not_at_position", value: "Red", position: 2 },
-      seatGrid,
+    expect(clue.text).toMatch(
+      /^(Alice is adjacent to Bob|Bob is adjacent to Alice)\.$/,
     );
-    expect(clue.text).toBe("The third seat is not red.");
   });
 
-  it("exact_distance singular uses custom noun", () => {
+  it("not_between uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 1 },
-      seatGrid,
+      {
+        type: "not_between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "House",
+      },
+      withComparators,
     );
-    expect(clue.text).toBe("Alice lives exactly one seat from the cat owner.");
+    expect(clue.text).toBe("Bob is not between Alice and Carol.");
   });
 
-  it("exact_distance plural uses custom noun", () => {
+  it("exact_distance uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 2 },
-      seatGrid,
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "House",
+      },
+      withComparators,
     );
-    expect(clue.text).toBe("Alice lives exactly two seats from the cat owner.");
+    expect(clue.text).toContain("is exactly");
   });
 
-  it("same_position color + pet uses custom noun and preposition", () => {
+  it("between uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "same_position", a: "Red", b: "Cat" },
-      seatGrid,
+      {
+        type: "between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "House",
+      },
+      withComparators,
     );
-    expect(clue.text).toBe("The cat owner lives at the red seat.");
+    expect(clue.text).toBe("Bob is between Alice and Carol.");
   });
+});
 
-  it("same_position name + color uses custom noun and preposition", () => {
-    const clue = renderClue(
-      { type: "same_position", a: "Alice", b: "Blue" },
-      seatGrid,
+describe("before with tuple comparator picks forward or reverse", () => {
+  // The default House category from grid has tuple comparators for before.
+  it("picks forward or reverse phrase deterministically", () => {
+    const aliceBob = renderClue(
+      { type: "before", a: "Alice", b: "Bob", axis: "House" },
+      grid,
     );
-    expect(clue.text).toBe("Alice lives at the blue seat.");
+    expect(aliceBob.text).toMatch(
+      /^(Alice lives somewhere left of Bob|Bob lives somewhere right of Alice)\.$/,
+    );
+    // Deterministic: same input → same output.
+    const again = renderClue(
+      { type: "before", a: "Alice", b: "Bob", axis: "House" },
+      grid,
+    );
+    expect(again.text).toBe(aliceBob.text);
   });
+});
 
-  it("not_same_position color + pet uses custom noun and preposition", () => {
+describe("left_of with tuple comparator picks forward or reverse", () => {
+  it("picks reverse phrasing when hash tiebreaker selects b as subject", () => {
+    // simpleHash("Alice"+"Bob") % 2 === 1 → reverse: Bob is subject
     const clue = renderClue(
-      { type: "not_same_position", a: "Red", b: "Cat" },
-      seatGrid,
+      { type: "left_of", a: "Alice", b: "Bob", axis: "House" },
+      grid,
     );
-    expect(clue.text).toBe("The cat owner does not live at the red seat.");
+    expect(clue.text).toBe("Bob lives directly right of Alice.");
   });
 
-  it("not_same_position color + drink uses custom noun", () => {
+  it("picks forward phrasing when hash tiebreaker selects a as subject", () => {
+    // simpleHash("Bob"+"Carol") % 2 === 0 → forward: Bob is subject
     const clue = renderClue(
-      { type: "not_same_position", a: "Blue", b: "Coffee" },
-      seatGrid,
-    );
-    expect(clue.text).toBe(
-      "The coffee drinker does not live at the blue seat.",
+      { type: "left_of", a: "Bob", b: "Carol", axis: "House" },
+      grid,
     );
-  });
-
-  it("throws when same_position rendering hits a verbless category", () => {
-    const minGrid = makeGrid({
-      size: 3,
-      categories: [
-        {
-          name: "Shape",
-          values: ["Circle", "Square", "Triangle"],
-          noun: "shape",
-        },
-        { name: "Size", values: ["Small", "Medium", "Large"], noun: "size" },
-      ],
-      positionNoun: ["slot", "slots"],
-      positionPreposition: "at",
-      spatialWords: DEFAULT_CONFIG.spatialWords,
-      positionLabels: ["the first slot", "the second slot", "the third slot"],
-    });
-    expect(() =>
-      renderClue({ type: "same_position", a: "Circle", b: "Small" }, minGrid),
-    ).toThrow("has no verb");
-  });
-
-  it("throws on empty positionNoun singular", () => {
-    const badGrid = makeGrid({
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-      ],
-      positionNoun: ["", "seats"],
-      spatialWords: {
-        verb: ["is", "is not"],
-        adjacency: "next to",
-        direction: ["left of", "right of"],
-        between: "somewhere between",
-        atPosition: ["is in", "is not in"],
-        cardinals: ["zero", "one", "two", "three"],
-      },
-    });
-    expect(() =>
-      renderClue(
-        { type: "exact_distance", a: "Alice", b: "Bob", distance: 1 },
-        badGrid,
-      ),
-    ).toThrow(RangeError);
-  });
-
-  it("throws on empty positionNoun plural", () => {
-    const badGrid = makeGrid({
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-      ],
-      positionNoun: ["seat", ""],
-      spatialWords: {
-        verb: ["is", "is not"],
-        adjacency: "next to",
-        direction: ["left of", "right of"],
-        between: "somewhere between",
-        atPosition: ["is at", "is not at"],
-        cardinals: ["zero", "one", "two", "three"],
-      },
-    });
-    expect(() =>
-      renderClue(
-        { type: "exact_distance", a: "Alice", b: "Bob", distance: 2 },
-        badGrid,
-      ),
-    ).toThrow(RangeError);
+    expect(clue.text).toBe("Bob lives directly left of Carol.");
   });
 });
 
-describe("position category", () => {
-  const posGrid = makeGrid({
+describe("per-axis orderingPhrases in rendering", () => {
+  // Grid with two ordered axes, each with its own comparator phrases.
+  const multiGrid = makeGrid({
     size: 3,
     categories: [
-      { name: "Manager", values: ["Alice", "Bob", "Carol"], noun: "" },
+      {
+        name: "Name",
+        values: ["Alice", "Bob", "Carol"],
+        noun: "",
+        subjectPriority: 2,
+      },
+      {
+        name: "Year",
+        values: ["2020", "2021", "2022"],
+        noun: "fund",
+        verb: ["was begun in", "was not begun in"],
+        ordered: true,
+        orderingPhrases: {
+          comparators: {
+            before: ["was begun earlier than", "was begun later than"] as [
+              string,
+              string,
+            ],
+            left_of: ["was begun right before", "was begun right after"] as [
+              string,
+              string,
+            ],
+            next_to: "was begun right before or after",
+            not_next_to: "was not begun right before or after",
+            between: "was begun between",
+            not_between: "was not begun between",
+            exact_distance: "was begun exactly",
+          },
+        },
+      },
       {
         name: "Return",
-        values: ["6%", "7%", "8%"],
+        values: ["5%", "6%", "7%"],
         noun: "fund",
-        isPosition: true,
-        numericValues: [6, 7, 8],
+        verb: ["has a return of", "does not have a return of"],
+        ordered: true,
         orderingPhrases: {
-          unit: ["percentage point", "percentage points"],
+          unit: ["percentage point", "percentage points"] as [string, string],
           comparators: {
-            before: "has a lower return than",
-            left_of: "has a return exactly one percentage point less than",
-            next_to: "has a return within one percentage point of",
-            not_next_to:
-              "does not have a return within one percentage point of",
+            before: ["has a lower return than", "has a higher return than"] as [
+              string,
+              string,
+            ],
+            left_of: [
+              "has a return right below",
+              "has a return right above",
+            ] as [string, string],
+            next_to: "has the return right above or below",
+            not_next_to: "does not have the return right above or below",
             between: "has a return between",
             not_between: "does not have a return between",
+            exact_distance: "is exactly",
           },
         },
       },
-      {
-        name: "Strategy",
-        values: ["Long/Short", "Macro", "Quant"],
-        noun: "strategist",
-      },
     ],
-    positionNoun: ["fund", "funds"],
-    positionPreposition: "at",
-    spatialWords: {
-      ...POSITIONAL_WORDS,
-      distanceUnit: ["percentage point", "percentage points"],
-    },
-    positionLabels: ["6%", "7%", "8%"],
   });
 
-  it("at_position uses position category label", () => {
+  it("before uses Year axis comparators when axis=Year", () => {
     const clue = renderClue(
-      { type: "at_position", value: "Alice", position: 0 },
-      posGrid,
+      { type: "before", a: "Alice", b: "Bob", axis: "Year" },
+      multiGrid,
     );
-    expect(clue.text).toBe("Alice is at 6%.");
+    expect(clue.text).toMatch(/was begun (earlier|later) than/);
   });
 
-  it("not_at_position uses position category label", () => {
+  it("before uses Return axis comparators when axis=Return", () => {
     const clue = renderClue(
-      { type: "not_at_position", value: "Alice", position: 2 },
-      posGrid,
+      { type: "before", a: "Alice", b: "Bob", axis: "Return" },
+      multiGrid,
     );
-    expect(clue.text).toBe("Alice is not at 8%.");
+    expect(clue.text).toMatch(/has a (lower|higher) return than/);
   });
 
-  it("before uses ordering templates", () => {
-    const clue = renderClue({ type: "before", a: "Alice", b: "Bob" }, posGrid);
-    expect(clue.text).toMatch(/somewhere (before|after)/);
-  });
-
-  it("left_of uses ordering templates", () => {
-    const clue = renderClue({ type: "left_of", a: "Alice", b: "Bob" }, posGrid);
-    expect(
-      clue.text === "Alice is directly before Bob." ||
-        clue.text === "Bob is directly after Alice.",
-    ).toBe(true);
-  });
-
-  it("left_of uses grid comparator when set", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          left_of: "has a return exactly one point less than",
-        },
-      },
-    };
-    const clue = renderClue({ type: "left_of", a: "Alice", b: "Bob" }, g);
-    expect(clue.text).toBe(
-      "Alice has a return exactly one point less than Bob.",
-    );
-  });
-
-  it("before uses grid comparator when set", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          before: "has a lower return than",
-        },
-      },
-    };
-    const clue = renderClue({ type: "before", a: "Alice", b: "Bob" }, g);
-    expect(clue.text).toBe("Alice has a lower return than Bob.");
-  });
-
-  it("before with tuple comparator picks forward or reverse phrasing", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          before: ["has a lower return than", "has a higher return than"],
-        },
-      },
-    };
-    // Hash tiebreaker: Alice+Bob → reverse, Bob+Carol → forward.
-    const aliceBob = renderClue({ type: "before", a: "Alice", b: "Bob" }, g);
-    expect(aliceBob.text).toBe("Bob has a higher return than Alice.");
-    const bobCarol = renderClue({ type: "before", a: "Bob", b: "Carol" }, g);
-    expect(bobCarol.text).toBe("Bob has a lower return than Carol.");
-  });
-
-  it("left_of with tuple comparator picks forward or reverse phrasing", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          left_of: [
-            "has the next lower return than",
-            "has the next higher return than",
-          ],
-        },
-      },
-    };
-    const clue = renderClue({ type: "left_of", a: "Alice", b: "Bob" }, g);
-    expect(clue.text).toMatch(
-      /^(Alice has the next lower return than Bob|Bob has the next higher return than Alice)\.$/,
-    );
-  });
-
-  it("exact_distance uses unit from ordering templates", () => {
+  it("next_to uses Year axis comparators when axis=Year", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 2 },
-      posGrid,
-    );
-    expect(clue.text).toMatch(
-      /^(Alice|Bob) is exactly 2 percentage points from (Alice|Bob)\.$/,
+      { type: "next_to", a: "Alice", b: "Bob", axis: "Year" },
+      multiGrid,
     );
+    expect(clue.text).toContain("was begun right before or after");
   });
 
-  it("exact_distance singular unit", () => {
+  it("next_to uses Return axis comparators when axis=Return", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 1 },
-      posGrid,
-    );
-    expect(clue.text).toMatch(
-      /^(Alice|Bob) is exactly 1 percentage point from (Alice|Bob)\.$/,
+      { type: "next_to", a: "Alice", b: "Bob", axis: "Return" },
+      multiGrid,
     );
+    expect(clue.text).toContain("has the return right above or below");
   });
 
-  it("next_to uses ordering templates", () => {
-    const clue = renderClue({ type: "next_to", a: "Alice", b: "Bob" }, posGrid);
-    // Same priority (both Manager) → deterministic hash tiebreaker
-    expect(clue.text).toMatch(
-      /^(Alice is adjacent to Bob|Bob is adjacent to Alice)\.$/,
-    );
-  });
-
-  it("not_next_to uses ordering templates", () => {
+  it("exact_distance uses per-axis unit when axis has one", () => {
     const clue = renderClue(
-      { type: "not_next_to", a: "Alice", b: "Bob" },
-      posGrid,
-    );
-    expect(clue.text).toMatch(
-      /^(Alice is not adjacent to Bob|Bob is not adjacent to Alice)\.$/,
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Return",
+      },
+      multiGrid,
     );
+    expect(clue.text).toContain("2 percentage points");
   });
 
-  it("between uses ordering templates", () => {
+  it("exact_distance without unit uses bare number", () => {
     const clue = renderClue(
-      { type: "between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      posGrid,
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Year",
+      },
+      multiGrid,
     );
-    expect(clue.text).toBe("Bob is somewhere between Alice and Carol.");
+    // Year has no unit → bare number.
+    expect(clue.text).toContain("2 from");
   });
+});
 
-  it("not_between uses ordering templates", () => {
-    const clue = renderClue(
-      { type: "not_between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      posGrid,
-    );
-    expect(clue.text).toBe("Bob is not somewhere between Alice and Carol.");
-  });
+describe("at_position / not_at_position invariants", () => {
+  const bareGrid: Grid = {
+    size: 3,
+    categories: [{ name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" }],
+  };
 
-  it("between uses grid comparator when set", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          between: "has a return between",
-        },
-      },
-    };
-    const clue = renderClue(
-      { type: "between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      g,
-    );
-    expect(clue.text).toBe("Bob has a return between Alice and Carol.");
+  it("at_position throws when grid has no ordered category", () => {
+    expect(() =>
+      renderClue(
+        { type: "at_position", value: "Alice", position: 0 },
+        bareGrid,
+      ),
+    ).toThrow("no ordered category");
   });
 
-  it("not_between uses grid comparator when set", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          not_between: "does not have a return between",
-        },
-      },
-    };
-    const clue = renderClue(
-      { type: "not_between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      g,
-    );
-    expect(clue.text).toBe(
-      "Bob does not have a return between Alice and Carol.",
-    );
+  it("not_at_position throws when grid has no ordered category", () => {
+    expect(() =>
+      renderClue(
+        { type: "not_at_position", value: "Alice", position: 0 },
+        bareGrid,
+      ),
+    ).toThrow("no ordered category");
   });
+
+  // "ordered category has no verb" is now a compile-time error:
+  // the OrderednessFields union requires verb on ordered: true.
 });
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 018c0d1..b1c8328 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -1,11 +1,5 @@
-import type {
-  Category,
-  Constraint,
-  Clue,
-  Grid,
-  OrderingComparatorType,
-} from "../types";
-import { posNoun, posNounPlural } from "../grid-utils";
+import type { Category, Constraint, Clue, Grid } from "../types";
+import { orderedCategories, resolveAxis } from "../axis";
 
 function findCategory(value: string, grid: Grid): Category {
   for (const cat of grid.categories) {
@@ -28,41 +22,33 @@ function objectValue(value: string, grid: Grid): string {
   return suffix ? `${value.toLowerCase()} ${suffix}` : value.toLowerCase();
 }
 
-function comparator(
-  grid: Grid,
-  type: OrderingComparatorType,
-): string | [string, string] | undefined {
-  return grid.spatialWords.comparators?.[type];
-}
-
-/**
- * Resolve a symmetric comparator. Tuples on symmetric types are rejected
- * by validateGrid in the generator, so we trust the type at render time.
- */
+/** Look up a symmetric comparator (plain string). */
 function symmetricComp(
   grid: Grid,
-  type: OrderingComparatorType,
-): string | undefined {
-  return comparator(grid, type) as string | undefined;
+  type:
+    | "next_to"
+    | "not_next_to"
+    | "between"
+    | "not_between"
+    | "exact_distance",
+  axisName: string,
+): string {
+  return resolveAxis(grid, axisName).orderingPhrases.comparators[type];
 }
 
 /**
- * Pick the directional comparator phrase. For tuples, uses `ordered()` to
- * decide which side becomes the subject (priority first, then hash tiebreaker)
- * and selects the matching forward/reverse phrase. For string comparators,
- * always uses constraint.a as subject (forward only).
+ * Pick the directional comparator phrase. Uses `ordered()` to decide which
+ * side becomes the subject (priority first, then hash tiebreaker) and selects
+ * the matching forward/reverse phrase from the tuple.
  */
 function directionalComp(
   grid: Grid,
-  type: OrderingComparatorType,
+  type: "before" | "left_of",
   a: string,
   b: string,
-): { subject: string; object: string; phrase: string } | undefined {
-  const c = comparator(grid, type);
-  if (c === undefined) return undefined;
-  if (typeof c === "string") {
-    return { subject: a, object: b, phrase: c };
-  }
+  axisName: string,
+): { subject: string; object: string; phrase: string } {
+  const c = resolveAxis(grid, axisName).orderingPhrases.comparators[type];
   const [s] = ordered(a, b, grid);
   return s === a
     ? { subject: a, object: b, phrase: c[0] }
@@ -101,9 +87,23 @@ function renderSamePosition(
   grid: Grid,
   negative: boolean,
 ): string {
+  const catA = findCategory(constraint.a, grid);
+  const catB = findCategory(constraint.b, grid);
+  const idx = negative ? 1 : 0;
+
+  // Position-adjective path: if one side has positionAdjective and the other
+  // is an ordered category, render the ordered value as subject with the
+  // adjective verb. Recovers the classical Color+House idiom:
+  // `same_position(Red, "1st")` → "The 1st house is red."
+  if (catA.positionAdjective && catB.ordered === true) {
+    return `${capitalize(label(constraint.b, grid))} ${catA.positionAdjective[idx]} ${constraint.a.toLowerCase()}.`;
+  }
+  if (catB.positionAdjective && catA.ordered === true) {
+    return `${capitalize(label(constraint.a, grid))} ${catB.positionAdjective[idx]} ${constraint.b.toLowerCase()}.`;
+  }
+
   const [subj, obj] = ordered(constraint.a, constraint.b, grid);
   const objCat = findCategory(obj, grid);
-  const idx = negative ? 1 : 0;
   const verb = objCat.verb;
   if (!verb) {
     throw new Error(
@@ -116,7 +116,6 @@ function renderSamePosition(
 // --- Main renderer ---
 
 function renderText(constraint: Constraint, grid: Grid): string {
-  const w = grid.spatialWords;
   switch (constraint.type) {
     case "same_position":
       return renderSamePosition(constraint, grid, false);
@@ -124,85 +123,83 @@ function renderText(constraint: Constraint, grid: Grid): string {
       return renderSamePosition(constraint, grid, true);
     case "next_to": {
       const [s, o] = ordered(constraint.a, constraint.b, grid);
-      const comp = symmetricComp(grid, "next_to");
-      return `${capitalize(label(s, grid))} ${comp ?? `${w.verb[0]} ${w.adjacency}`} ${label(o, grid)}.`;
+      const comp = symmetricComp(grid, "next_to", constraint.axis);
+      return `${capitalize(label(s, grid))} ${comp} ${label(o, grid)}.`;
     }
     case "not_next_to": {
       const [s, o] = ordered(constraint.a, constraint.b, grid);
-      const comp = symmetricComp(grid, "not_next_to");
-      return `${capitalize(label(s, grid))} ${comp ?? `${w.verb[1]} ${w.adjacency}`} ${label(o, grid)}.`;
+      const comp = symmetricComp(grid, "not_next_to", constraint.axis);
+      return `${capitalize(label(s, grid))} ${comp} ${label(o, grid)}.`;
     }
     case "left_of": {
-      const comp = directionalComp(grid, "left_of", constraint.a, constraint.b);
-      if (comp) {
-        return `${capitalize(label(comp.subject, grid))} ${comp.phrase} ${label(comp.object, grid)}.`;
-      }
-      const [s, o] = ordered(constraint.a, constraint.b, grid);
-      const dir = s === constraint.a ? w.direction[0] : w.direction[1];
-      return `${capitalize(label(s, grid))} ${w.verb[0]} directly ${dir} ${label(o, grid)}.`;
+      const comp = directionalComp(
+        grid,
+        "left_of",
+        constraint.a,
+        constraint.b,
+        constraint.axis,
+      );
+      return `${capitalize(label(comp.subject, grid))} ${comp.phrase} ${label(comp.object, grid)}.`;
     }
     case "between": {
       const lm = label(constraint.middle, grid);
       const lo1 = label(constraint.outer1, grid);
       const lo2 = label(constraint.outer2, grid);
-      const comp = symmetricComp(grid, "between");
-      if (comp) return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
-      const middleVerb =
-        findCategory(constraint.middle, grid).positionAdjective?.[0] ??
-        w.verb[0];
-      return `${capitalize(lm)} ${middleVerb} ${w.between} ${lo1} and ${lo2}.`;
+      const comp = symmetricComp(grid, "between", constraint.axis);
+      return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
     }
     case "not_between": {
       const lm = label(constraint.middle, grid);
       const lo1 = label(constraint.outer1, grid);
       const lo2 = label(constraint.outer2, grid);
-      const comp = symmetricComp(grid, "not_between");
-      if (comp) return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
-      const middleVerb =
-        findCategory(constraint.middle, grid).positionAdjective?.[1] ??
-        w.verb[1];
-      return `${capitalize(lm)} ${middleVerb} ${w.between} ${lo1} and ${lo2}.`;
+      const comp = symmetricComp(grid, "not_between", constraint.axis);
+      return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
     }
     case "before": {
-      const comp = directionalComp(grid, "before", constraint.a, constraint.b);
-      if (comp) {
-        return `${capitalize(label(comp.subject, grid))} ${comp.phrase} ${label(comp.object, grid)}.`;
-      }
-      const [s, o] = ordered(constraint.a, constraint.b, grid);
-      const dir = s === constraint.a ? w.direction[0] : w.direction[1];
-      return `${capitalize(label(s, grid))} ${w.verb[0]} somewhere ${dir} ${label(o, grid)}.`;
+      const comp = directionalComp(
+        grid,
+        "before",
+        constraint.a,
+        constraint.b,
+        constraint.axis,
+      );
+      return `${capitalize(label(comp.subject, grid))} ${comp.phrase} ${label(comp.object, grid)}.`;
     }
     case "exact_distance": {
       const [s, o] = ordered(constraint.a, constraint.b, grid);
       const la = label(s, grid);
       const lb = label(o, grid);
-      const unit = w.distanceUnit;
-      const prefix =
-        symmetricComp(grid, "exact_distance") ?? `${w.verb[0]} exactly`;
+      const axisCategory = resolveAxis(grid, constraint.axis);
+      const unit = axisCategory.orderingPhrases?.unit;
+      const prefix = symmetricComp(grid, "exact_distance", constraint.axis);
       if (unit) {
         const unitNoun = constraint.distance === 1 ? unit[0] : unit[1];
         return `${capitalize(la)} ${prefix} ${constraint.distance} ${unitNoun} from ${lb}.`;
       }
-      const dist = w.cardinals[constraint.distance];
-      const noun =
-        constraint.distance === 1 ? posNoun(grid) : posNounPlural(grid);
-      return `${capitalize(la)} ${prefix} ${dist} ${noun} from ${lb}.`;
+      return `${capitalize(la)} ${prefix} ${constraint.distance} from ${lb}.`;
     }
     case "at_position": {
-      const posLabel = grid.positionLabels[constraint.position];
+      // Uses the first ordered category (identity-pinned), NOT displayAxis.
+      // at_position encodes row identity, which is tied to the identity-pinned
+      // axis. displayAxis is a presentation concern for column headers only.
+      const axis = orderedCategories(grid)[0];
+      if (!axis) throw new Error("Grid has no ordered category");
+      const axisVal = axis.values[constraint.position];
       const cat = findCategory(constraint.value, grid);
       if (cat.positionAdjective) {
-        return `${capitalize(posLabel)} ${cat.positionAdjective[0]} ${constraint.value.toLowerCase()}.`;
+        return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[0]} ${constraint.value.toLowerCase()}.`;
       }
-      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[0]} ${posLabel}.`;
+      return `${capitalize(label(constraint.value, grid))} ${axis.verb[0]} ${objectValue(axisVal, grid)}.`;
     }
     case "not_at_position": {
-      const posLabel = grid.positionLabels[constraint.position];
+      const axis = orderedCategories(grid)[0];
+      if (!axis) throw new Error("Grid has no ordered category");
+      const axisVal = axis.values[constraint.position];
       const cat = findCategory(constraint.value, grid);
       if (cat.positionAdjective) {
-        return `${capitalize(posLabel)} ${cat.positionAdjective[1]} ${constraint.value.toLowerCase()}.`;
+        return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[1]} ${constraint.value.toLowerCase()}.`;
       }
-      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[1]} ${posLabel}.`;
+      return `${capitalize(label(constraint.value, grid))} ${axis.verb[1]} ${objectValue(axisVal, grid)}.`;
     }
   }
 }
diff --git a/packages/logic-grid/src/deduce/__snapshots__/index.test.ts.snap b/packages/logic-grid/src/deduce/__snapshots__/index.test.ts.snap
index 2d27e9f..8fb39ec 100644
--- a/packages/logic-grid/src/deduce/__snapshots__/index.test.ts.snap
+++ b/packages/logic-grid/src/deduce/__snapshots__/index.test.ts.snap
@@ -2,19 +2,19 @@
 
 exports[`deduce > snapshots explanation strings 1`] = `
 [
-  "Clue 1: Red must be in the first house.",
-  "Clue 2: Red and Cat are in the same house. Red is in the first house, so both are in the first house.",
-  "Clue 3: Blue is directly left of Green. Blue can only be in the first or second house, so Blue can't be in the third house; Green can't be in the first house.",
-  "Clue 4: Blue and Dog are in the same house. Blue can only be in the first or second house, so Dog can't be in the third house.",
-  "Clue 5: Dog and Coffee are in the same house. Dog can only be in the first or second house, so Coffee can't be in the third house.",
-  "Clue 6: Tea must be in the first house.",
-  "Red has no other possible position — it must be in the first house. So no other Color can be there.",
-  "Clue 3: Blue is directly left of Green. Blue is in the second house, so Green must be in the third house.",
-  "Clue 4: Blue and Dog are in the same house. Blue is in the second house, so both are in the second house.",
-  "Clue 5: Dog and Coffee are in the same house. Dog is in the second house, so both are in the second house.",
-  "Cat has no other possible position — it must be in the first house. So no other Pet can be there.",
-  "Dog has no other possible position — it must be in the second house. So no other Pet can be there.",
-  "Tea has no other possible position — it must be in the first house. So no other Drink can be there.",
-  "Coffee has no other possible position — it must be in the second house. So no other Drink can be there.",
+  "Clue 1: Red must be in the first position.",
+  "Clue 2: Red and Cat are in the same position. Red is in the first position, so both are in the first position.",
+  "Clue 3: Blue is directly left of Green. Blue can only be in the first or second position, so Blue can't be in the third position; Green can't be in the first position.",
+  "Clue 4: Blue and Dog are in the same position. Blue can only be in the first or second position, so Dog can't be in the third position.",
+  "Clue 5: Dog and Coffee are in the same position. Dog can only be in the first or second position, so Coffee can't be in the third position.",
+  "Clue 6: Tea must be in the first position.",
+  "Red has no other possible position — it must be in the first position. So no other Color can be there.",
+  "Clue 3: Blue is directly left of Green. Blue is in the second position, so Green must be in the third position.",
+  "Clue 4: Blue and Dog are in the same position. Blue is in the second position, so both are in the second position.",
+  "Clue 5: Dog and Coffee are in the same position. Dog is in the second position, so both are in the second position.",
+  "Cat has no other possible position — it must be in the first position. So no other Pet can be there.",
+  "Dog has no other possible position — it must be in the second position. So no other Pet can be there.",
+  "Tea has no other possible position — it must be in the first position. So no other Drink can be there.",
+  "Coffee has no other possible position — it must be in the second position. So no other Drink can be there.",
 ]
 `;
diff --git a/packages/logic-grid/src/deduce/constraints.test.ts b/packages/logic-grid/src/deduce/constraints.test.ts
index edab28c..87d8dad 100644
--- a/packages/logic-grid/src/deduce/constraints.test.ts
+++ b/packages/logic-grid/src/deduce/constraints.test.ts
@@ -3,17 +3,8 @@ import { deduce } from ".";
 import { tryConstraint } from "./constraints";
 import { ordinal } from "../grid-utils";
 import { createState, getPossible } from "./state";
-import { makeGrid } from "../test-helpers";
-import type { Constraint, SpatialWords } from "../types";
-
-const POSITIONAL_WORDS: SpatialWords = {
-  verb: ["is", "is not"],
-  adjacency: "adjacent to",
-  direction: ["before", "after"],
-  between: "somewhere between",
-  atPosition: ["is at", "is not at"],
-  cardinals: ["zero", "one", "two", "three", "four", "five", "six", "seven"],
-};
+import { makeGrid, TEST_COMPARATORS } from "../test-helpers";
+import type { Constraint } from "../types";
 
 const grid = makeGrid({
   size: 4,
@@ -72,7 +63,7 @@ describe("deduce constraint types", () => {
   it("next_to constrains to adjacent positions", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 0 },
-      { type: "next_to", a: "Red", b: "Alice" },
+      { type: "next_to", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "next_to");
@@ -86,7 +77,7 @@ describe("deduce constraint types", () => {
   it("not_next_to eliminates adjacent positions when a is pinned", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 1 },
-      { type: "not_next_to", a: "Red", b: "Alice" },
+      { type: "not_next_to", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "not_next_to");
@@ -98,7 +89,7 @@ describe("deduce constraint types", () => {
   it("not_next_to eliminates adjacent positions when b is pinned", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 1 },
-      { type: "not_next_to", a: "Red", b: "Alice" },
+      { type: "not_next_to", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "not_next_to");
@@ -113,7 +104,7 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "not_at_position", value: "Blue", position: 1 },
       { type: "not_at_position", value: "Blue", position: 3 },
-      { type: "not_next_to", a: "Red", b: "Blue" },
+      { type: "not_next_to", a: "Red", b: "Blue", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -146,7 +137,7 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Blue", position: 5 },
       { type: "not_at_position", value: "Blue", position: 6 },
       { type: "not_at_position", value: "Blue", position: 7 },
-      { type: "next_to", a: "Red", b: "Blue" },
+      { type: "next_to", a: "Red", b: "Blue", axis: "House" },
     ];
     const result = deduce(constraints, grid8);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -156,7 +147,7 @@ describe("deduce constraint types", () => {
   it("left_of pins b to a+1 when a is pinned", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 1 },
-      { type: "left_of", a: "Red", b: "Alice" },
+      { type: "left_of", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "left_of");
@@ -169,7 +160,7 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "not_at_position", value: "Alice", position: 0 },
       { type: "not_at_position", value: "Alice", position: 1 },
-      { type: "left_of", a: "Red", b: "Alice" },
+      { type: "left_of", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -203,7 +194,7 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
       { type: "not_at_position", value: "Blue", position: 2 },
-      { type: "left_of", a: "Red", b: "Blue" },
+      { type: "left_of", a: "Red", b: "Blue", axis: "House" },
     ];
     const result = deduce(constraints, grid8);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -236,7 +227,7 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
       { type: "not_at_position", value: "Blue", position: 2 },
-      { type: "before", a: "Red", b: "Blue" },
+      { type: "before", a: "Red", b: "Blue", axis: "House" },
     ];
     const result = deduce(constraints, grid8);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -249,7 +240,7 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "not_at_position", value: "Red", position: 0 },
       { type: "not_at_position", value: "Red", position: 2 },
-      { type: "next_to", a: "Red", b: "Alice" },
+      { type: "next_to", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -260,7 +251,7 @@ describe("deduce constraint types", () => {
   it("before eliminates positions", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 2 },
-      { type: "before", a: "Red", b: "Alice" },
+      { type: "before", a: "Red", b: "Alice", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "before");
@@ -274,7 +265,7 @@ describe("deduce constraint types", () => {
     // After Red becomes {0,1}, Blue can't be at 0 (≤ minRed=0).
     const constraints: Constraint[] = [
       { type: "not_at_position", value: "Blue", position: 3 },
-      { type: "before", a: "Red", b: "Blue" },
+      { type: "before", a: "Red", b: "Blue", axis: "House" },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -290,7 +281,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "not_at_position", value: "Blue", position: 2 },
       { type: "not_at_position", value: "Blue", position: 3 },
-      { type: "exact_distance", a: "Red", b: "Blue", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Blue",
+        distance: 2,
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -321,7 +318,13 @@ describe("deduce constraint types", () => {
       ],
     });
     const constraints: Constraint[] = [
-      { type: "exact_distance", a: "Red", b: "Blue", distance: 5 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Blue",
+        distance: 5,
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid8);
     const step = result.steps.find((s) => s.technique === "exact_distance");
@@ -330,10 +333,81 @@ describe("deduce constraint types", () => {
     expect(step!.eliminations).toContainEqual({ value: "Blue", position: 3 });
   });
 
+  it("exact_distance explanation uses generic 'positions' when axis has no unit", () => {
+    // Build a grid with an ordered category that has comparators but no unit.
+    const noUnitGrid = makeGrid({
+      size: 4,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol", "Dave"], noun: "" },
+        {
+          name: "Rank",
+          values: ["A", "B", "C", "D"],
+          noun: "rank",
+          verb: ["is ranked", "is not ranked"],
+          ordered: true,
+          orderingPhrases: {
+            comparators: TEST_COMPARATORS,
+          },
+        },
+      ],
+    });
+    const constraints: Constraint[] = [
+      { type: "at_position", value: "Alice", position: 0 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Rank",
+      },
+    ];
+    const result = deduce(constraints, noUnitGrid);
+    const step = result.steps.find((s) => s.technique === "exact_distance");
+    expect(step).toBeDefined();
+    expect(step!.explanation).toContain("2 positions");
+  });
+
+  it("exact_distance explanation uses singular 'position' when distance=1 and no unit", () => {
+    const noUnitGrid = makeGrid({
+      size: 4,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol", "Dave"], noun: "" },
+        {
+          name: "Rank",
+          values: ["A", "B", "C", "D"],
+          noun: "rank",
+          verb: ["is ranked", "is not ranked"],
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
+      ],
+    });
+    const constraints: Constraint[] = [
+      { type: "at_position", value: "Alice", position: 0 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 1,
+        axis: "Rank",
+      },
+    ];
+    const result = deduce(constraints, noUnitGrid);
+    const step = result.steps.find((s) => s.technique === "exact_distance");
+    expect(step).toBeDefined();
+    expect(step!.explanation).toContain("1 position");
+  });
+
   it("exact_distance constrains positions", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 0 },
-      { type: "exact_distance", a: "Red", b: "Alice", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Alice",
+        distance: 2,
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "exact_distance");
@@ -353,8 +427,9 @@ describe("deduce constraint types", () => {
           noun: "fund",
           verb: ["has a return of", "does not have a return of"],
           subjectPriority: -1,
-          isPosition: true,
+          ordered: true,
           numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
@@ -362,7 +437,13 @@ describe("deduce constraint types", () => {
     // at positions (0,1) — so Bob is at position 1.
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Return",
+      },
     ];
     const result = deduce(constraints, numGrid);
     const step = result.steps.find((s) => s.technique === "exact_distance");
@@ -382,14 +463,21 @@ describe("deduce constraint types", () => {
           noun: "fund",
           verb: ["has a return of", "does not have a return of"],
           subjectPriority: -1,
-          isPosition: true,
+          ordered: true,
           numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 6 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 6,
+        axis: "Return",
+      },
     ];
     const result = deduce(constraints, numGrid);
     // Bob has no valid position; this should be detected as inconsistent
@@ -403,7 +491,13 @@ describe("deduce constraint types", () => {
     // Alice pinned to position 0; Red must be exactly 1 house away → Red=1
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
-      { type: "exact_distance", a: "Red", b: "Alice", distance: 1 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Alice",
+        distance: 1,
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "exact_distance");
@@ -412,7 +506,7 @@ describe("deduce constraint types", () => {
     expect(step!.explanation).toContain("1 house apart");
   });
 
-  it("exact_distance explanation uses unit from position category", () => {
+  it("exact_distance explanation uses unit from orderingPhrases", () => {
     const unitGrid = makeGrid({
       size: 4,
       categories: [
@@ -421,22 +515,25 @@ describe("deduce constraint types", () => {
           name: "Return",
           values: ["6%", "7%", "8%", "9%"],
           noun: "fund",
-          isPosition: true,
+          verb: ["has a return of", "does not have a return of"],
+          ordered: true,
           numericValues: [6, 7, 8, 9],
           orderingPhrases: {
             unit: ["percentage point", "percentage points"],
+            comparators: TEST_COMPARATORS,
           },
         },
       ],
-      spatialWords: {
-        ...POSITIONAL_WORDS,
-        distanceUnit: ["percentage point", "percentage points"],
-      },
-      positionLabels: ["6%", "7%", "8%", "9%"],
     });
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Return",
+      },
     ];
     const result = deduce(constraints, unitGrid);
     const step = result.steps.find((s) => s.technique === "exact_distance");
@@ -453,22 +550,25 @@ describe("deduce constraint types", () => {
           name: "Return",
           values: ["6%", "7%", "8%", "9%"],
           noun: "fund",
-          isPosition: true,
+          verb: ["has a return of", "does not have a return of"],
+          ordered: true,
           numericValues: [6, 7, 8, 9],
           orderingPhrases: {
             unit: ["percentage point", "percentage points"],
+            comparators: TEST_COMPARATORS,
           },
         },
       ],
-      spatialWords: {
-        ...POSITIONAL_WORDS,
-        distanceUnit: ["percentage point", "percentage points"],
-      },
-      positionLabels: ["6%", "7%", "8%", "9%"],
     });
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 1 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 1,
+        axis: "Return",
+      },
     ];
     const result = deduce(constraints, unitGrid);
     const step = result.steps.find((s) => s.technique === "exact_distance");
@@ -487,7 +587,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 0 },
       { type: "at_position", value: "Blue", position: 4 },
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid5);
     const step = result.steps.find((s) => s.technique === "between");
@@ -508,7 +614,13 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Red", position: 3 },
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 3 },
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -537,7 +649,13 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Red", position: 5 },
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid6);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -550,7 +668,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 2 },
       { type: "at_position", value: "Red", position: 0 },
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -566,7 +690,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 1 },
       { type: "at_position", value: "Red", position: 3 },
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -583,7 +713,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 2 },
       { type: "at_position", value: "Blue", position: 0 },
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -615,7 +751,13 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
       { type: "not_at_position", value: "Blue", position: 2 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid5);
     const step = result.steps.find((s) => s.technique === "not_between");
@@ -642,7 +784,13 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Blue", position: 2 },
       { type: "not_at_position", value: "Blue", position: 3 },
       { type: "not_at_position", value: "Blue", position: 4 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid5);
     const step = result.steps.find((s) => s.technique === "not_between");
@@ -654,7 +802,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 0 },
       { type: "at_position", value: "Blue", position: 3 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const step = result.steps.find((s) => s.technique === "not_between");
@@ -669,7 +823,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Red", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -682,7 +842,13 @@ describe("deduce constraint types", () => {
     const constraints: Constraint[] = [
       { type: "at_position", value: "Blue", position: 3 },
       { type: "not_at_position", value: "Red", position: 2 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -710,7 +876,13 @@ describe("deduce constraint types", () => {
       { type: "at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Red", position: 0 },
       { type: "not_at_position", value: "Red", position: 1 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid6);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -725,7 +897,13 @@ describe("deduce constraint types", () => {
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
       { type: "not_at_position", value: "Blue", position: 2 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     const result = deduce(constraints, grid);
     const allElims = result.steps.flatMap((s) => s.eliminations);
@@ -740,7 +918,7 @@ describe("empty-set guards", () => {
     getPossible(state, "Red").clear();
     const result = tryConstraint(
       state,
-      { type: "before", a: "Red", b: "Alice" },
+      { type: "before", a: "Red", b: "Alice", axis: "House" },
       0,
     );
     expect(result).toBeNull();
@@ -756,7 +934,13 @@ describe("empty-set guards", () => {
     getPossible(state, "Blue").clear();
     const result = tryConstraint(
       state,
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
       0,
     );
     expect(result).toBeNull();
@@ -767,7 +951,13 @@ describe("empty-set guards", () => {
     getPossible(state, "Red").clear();
     const result = tryConstraint(
       state,
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
       0,
     );
     expect(result).toBeNull();
@@ -778,7 +968,13 @@ describe("empty-set guards", () => {
     getPossible(state, "Red").clear();
     const result = tryConstraint(
       state,
-      { type: "between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
       0,
     );
     expect(result).toBeNull();
@@ -794,3 +990,289 @@ describe("ordinal", () => {
     expect(() => ordinal(-1)).toThrow("out of supported range");
   });
 });
+
+describe("rank-space deduction on non-pinned axis", () => {
+  // Year is the first ordered category (identity-pinned). Return is the
+  // second (not pinned) — constraints targeting Return go through the
+  // rank-space path.
+  const multiGrid = makeGrid({
+    size: 4,
+    categories: [
+      { name: "Name", values: ["Alice", "Bob", "Carol", "Dave"], noun: "" },
+      {
+        name: "Year",
+        values: ["2020", "2021", "2022", "2023"],
+        noun: "fund",
+        verb: ["was begun in", "was not begun in"],
+        ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
+      },
+      {
+        name: "Return",
+        values: ["5%", "6%", "7%", "8%"],
+        noun: "fund",
+        verb: ["has a return of", "does not have a return of"],
+        ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
+      },
+    ],
+  });
+
+  it("before on non-pinned axis propagates", () => {
+    // Pin 8% to position 0, so Alice at pos 0 has return rank 3 (the highest).
+    // before(Alice, Bob, Return) means Alice's return rank < Bob's → but
+    // rank 3 is the max, so no Bob can be strictly greater → Alice can't be
+    // at pos 0 if 8% is the only option there. However, since 8% isn't pinned
+    // to position 0 in the deduce state (Return is not identity-pinned),
+    // we use a simpler test: pin Alice to a single return rank and verify
+    // eliminations happen.
+    //
+    // Instead, let's use same_position to co-locate Alice with 8%, then
+    // check that before(Alice, Bob, Return) produces eliminations via the
+    // rank-space path.
+    const constraints: Constraint[] = [
+      { type: "same_position", a: "Alice", b: "8%" },
+      { type: "before", a: "Alice", b: "Bob", axis: "Return" },
+    ];
+    const result = deduce(constraints, multiGrid);
+    // With Alice at rank 3 (highest), there's no rank > 3 for Bob.
+    // The before constraint is unsatisfiable — the solver should detect
+    // this via contradiction or at least produce some propagation.
+    expect(result.steps.length).toBeGreaterThan(0);
+  });
+
+  it("before on non-pinned axis: tryConstraint returns a step", () => {
+    // Use tryConstraint directly with a pre-configured state to exercise
+    // the rank-space path. Pin Alice to position 0 and 8% to position 0
+    // via state manipulation, so Alice's rank domain on Return = {3}.
+    // before(Alice, Bob, Return) → rank(Alice)=3 is the max, no valid Bob
+    // rank > 3 exists → Alice's position 0 should be eliminated.
+    const state = createState(multiGrid);
+    // Pin Alice and 8% to position 0 (co-located).
+    for (let p = 1; p < 4; p++) {
+      getPossible(state, "Alice").delete(p);
+      getPossible(state, "8%").delete(p);
+    }
+    // Remove other Return values from position 0 so 8% is the only one there.
+    getPossible(state, "5%").delete(0);
+    getPossible(state, "6%").delete(0);
+    getPossible(state, "7%").delete(0);
+
+    const result = tryConstraint(
+      state,
+      { type: "before", a: "Alice", b: "Bob", axis: "Return" },
+      0,
+    );
+    // Alice at rank 3, no rank > 3 for Bob → Alice's position 0 eliminated.
+    expect(result).not.toBeNull();
+    expect(result!.eliminations).toContainEqual({
+      value: "Alice",
+      position: 0,
+    });
+  });
+
+  it("left_of on non-pinned axis: tryConstraint returns a step", () => {
+    // Pin Alice at rank 3 (8%). left_of(Alice, Bob, Return) means
+    // rank(Bob) = rank(Alice) + 1 = 4, which doesn't exist → eliminate.
+    const state = createState(multiGrid);
+    for (let p = 1; p < 4; p++) {
+      getPossible(state, "Alice").delete(p);
+      getPossible(state, "8%").delete(p);
+    }
+    getPossible(state, "5%").delete(0);
+    getPossible(state, "6%").delete(0);
+    getPossible(state, "7%").delete(0);
+
+    const result = tryConstraint(
+      state,
+      { type: "left_of", a: "Alice", b: "Bob", axis: "Return" },
+      0,
+    );
+    expect(result).not.toBeNull();
+    expect(result!.eliminations).toContainEqual({
+      value: "Alice",
+      position: 0,
+    });
+  });
+
+  it("not_between on non-pinned axis: tryConstraint returns a step", () => {
+    // Pin Alice at rank 1 (6%), Bob at rank 0 (5%), Carol at rank 3 (8%).
+    // not_between(Bob, Alice, Carol, Return): Alice at rank 1 is strictly
+    // between ranks 0 and 3 → violated → Alice's position eliminated.
+    const state = createState(multiGrid);
+    // Pin 5% to pos 0 only, 6% to pos 1 only, 8% to pos 3 only.
+    for (let p = 0; p < 4; p++) {
+      if (p !== 0) getPossible(state, "5%").delete(p);
+      if (p !== 1) getPossible(state, "6%").delete(p);
+      if (p !== 3) getPossible(state, "8%").delete(p);
+    }
+    // Pin Bob to pos 0 (rank 0 via 5%), Alice to pos 1 (rank 1 via 6%),
+    // Carol to pos 3 (rank 3 via 8%).
+    for (let p = 0; p < 4; p++) {
+      if (p !== 0) getPossible(state, "Bob").delete(p);
+      if (p !== 1) getPossible(state, "Alice").delete(p);
+      if (p !== 3) getPossible(state, "Carol").delete(p);
+    }
+    // Remove other Return values from those positions.
+    getPossible(state, "7%").delete(0);
+    getPossible(state, "7%").delete(1);
+    getPossible(state, "7%").delete(3);
+
+    const result = tryConstraint(
+      state,
+      {
+        type: "not_between",
+        outer1: "Bob",
+        middle: "Alice",
+        outer2: "Carol",
+        axis: "Return",
+      },
+      0,
+    );
+    // Alice at rank 1 is between ranks 0 and 3 → not_between violated →
+    // Alice's position 1 should be eliminated.
+    expect(result).not.toBeNull();
+    expect(result!.eliminations).toContainEqual({
+      value: "Alice",
+      position: 1,
+    });
+  });
+
+  it("between rank-space returns null when a rank domain is empty", () => {
+    const state = createState(multiGrid);
+    // Clear all positions for Alice → empty rank domain.
+    getPossible(state, "Alice").clear();
+    const result = tryConstraint(
+      state,
+      {
+        type: "between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "Return",
+      },
+      0,
+    );
+    expect(result).toBeNull();
+  });
+
+  it("exact_distance rank-space with numericValues uses value distance", () => {
+    // Use a grid where Return has numericValues and is non-pinned.
+    const numGrid = makeGrid({
+      size: 4,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol", "Dave"], noun: "" },
+        {
+          name: "Year",
+          values: ["2020", "2021", "2022", "2023"],
+          noun: "fund",
+          verb: ["started in", "did not start in"],
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
+        {
+          name: "Return",
+          values: ["3%", "5%", "8%", "12%"],
+          noun: "fund",
+          verb: ["has a return of", "does not have a return of"],
+          ordered: true,
+          numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
+      ],
+    });
+    const state = createState(numGrid);
+    // Pin Alice at position 0, 3% at position 0 → Alice has Return rank 0.
+    for (let p = 1; p < 4; p++) {
+      getPossible(state, "Alice").delete(p);
+      getPossible(state, "3%").delete(p);
+    }
+    getPossible(state, "5%").delete(0);
+    getPossible(state, "8%").delete(0);
+    getPossible(state, "12%").delete(0);
+
+    // distance=2 with numericValues [3,5,8,12]: |3-5|=2 → rank 1 valid.
+    // No other rank has value distance 2 from rank 0.
+    const result = tryConstraint(
+      state,
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Return",
+      },
+      0,
+    );
+    expect(result).not.toBeNull();
+  });
+
+  it("exact_distance rank-space without numericValues uses rank steps", () => {
+    // Year has no numericValues in multiGrid → rank-step distance.
+    // But Year IS identity-pinned (first ordered), so we need a grid where
+    // a non-pinned axis has no numericValues. Return has none in multiGrid.
+    const state = createState(multiGrid);
+    // Pin Alice at rank 0 (5%) by clearing all other positions and values.
+    for (let p = 1; p < 4; p++) {
+      getPossible(state, "Alice").delete(p);
+      getPossible(state, "5%").delete(p);
+    }
+    getPossible(state, "6%").delete(0);
+    getPossible(state, "7%").delete(0);
+    getPossible(state, "8%").delete(0);
+
+    const result = tryConstraint(
+      state,
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 3,
+        axis: "Return",
+      },
+      0,
+    );
+    // Alice at rank 0, distance 3 → Bob must be at rank 3.
+    // This should produce some propagation.
+    expect(result).not.toBeNull();
+  });
+
+  it("between on non-pinned axis: tryConstraint returns a step", () => {
+    // Pin Alice at rank 3 (8%), Bob at rank 0 (5%).
+    // between(Bob, Carol, Alice, Return): Carol must be strictly between
+    // ranks 0 and 3. Pin Carol at rank 0 (5% at same pos) → violated.
+    const state = createState(multiGrid);
+    for (let p = 0; p < 4; p++) {
+      if (p !== 0) getPossible(state, "5%").delete(p);
+      if (p !== 3) getPossible(state, "8%").delete(p);
+    }
+    for (let p = 0; p < 4; p++) {
+      if (p !== 0) getPossible(state, "Bob").delete(p);
+      if (p !== 0) getPossible(state, "Carol").delete(p);
+      if (p !== 3) getPossible(state, "Alice").delete(p);
+    }
+    getPossible(state, "6%").delete(0);
+    getPossible(state, "6%").delete(3);
+    getPossible(state, "7%").delete(0);
+    getPossible(state, "7%").delete(3);
+
+    const result = tryConstraint(
+      state,
+      {
+        type: "between",
+        outer1: "Bob",
+        middle: "Carol",
+        outer2: "Alice",
+        axis: "Return",
+      },
+      0,
+    );
+    // Carol at rank 0 (same as Bob) is not strictly between 0 and 3 →
+    // Carol's position 0 should be eliminated.
+    expect(result).not.toBeNull();
+    expect(result!.eliminations).toContainEqual({
+      value: "Carol",
+      position: 0,
+    });
+  });
+});
diff --git a/packages/logic-grid/src/deduce/constraints.ts b/packages/logic-grid/src/deduce/constraints.ts
index 2f94b9d..e1b30df 100644
--- a/packages/logic-grid/src/deduce/constraints.ts
+++ b/packages/logic-grid/src/deduce/constraints.ts
@@ -1,11 +1,11 @@
-import type { Constraint, DeductionStep, DeductionTechnique } from "../types";
-import {
-  ordinal,
-  posNoun,
-  posNounPlural,
-  posPrep,
-  findPositionCategory,
-} from "../grid-utils";
+import type {
+  Category,
+  Constraint,
+  DeductionStep,
+  DeductionTechnique,
+} from "../types";
+import { ordinal } from "../grid-utils";
+import { resolveAxis } from "../axis";
 import {
   type DeduceState,
   SILENT_STEP,
@@ -18,6 +18,8 @@ import {
   describeResult,
   clueRef,
   describeKnown,
+  axisRankDomain,
+  projectRanksToPositions,
 } from "./state";
 
 /** Check whether every position in `set` is adjacent to `p`. */
@@ -28,6 +30,78 @@ function allAdjacent(set: Set<number>, p: number): boolean {
   return true;
 }
 
+/** True when `axis` is the first ordered category (identity-pinned). */
+function isIdentityPinned(
+  grid: { categories: Category[] },
+  axis: Category,
+): boolean {
+  return grid.categories.find((c) => c.ordered === true) === axis;
+}
+
+/**
+ * Generic rank-space deduction for binary comparative constraints on a
+ * non-identity-pinned axis. Computes the rank domain of both values,
+ * applies the predicate `isValid(rankA, rankB)` to decide which ranks
+ * to eliminate, then projects back to position eliminations.
+ */
+function tryBinaryRankSpace(
+  state: DeduceState,
+  a: string,
+  b: string,
+  axis: Category,
+  ci: number,
+  technique: DeductionTechnique,
+  isValid: (rankA: number, rankB: number) => boolean,
+  description: string,
+): DeductionStep | null {
+  const rankA = axisRankDomain(state, a, axis);
+  const rankB = axisRankDomain(state, b, axis);
+  if (rankA.size === 0 || rankB.size === 0) return null;
+
+  // Find ranks to eliminate: a rank is bad for value X if no rank of Y satisfies the predicate.
+  const badRanksA = new Set<number>();
+  for (const ra of rankA) {
+    let hasValidB = false;
+    for (const rb of rankB) {
+      if (isValid(ra, rb)) {
+        hasValidB = true;
+        break;
+      }
+    }
+    if (!hasValidB) badRanksA.add(ra);
+  }
+  const badRanksB = new Set<number>();
+  for (const rb of rankB) {
+    let hasValidA = false;
+    for (const ra of rankA) {
+      if (isValid(ra, rb)) {
+        hasValidA = true;
+        break;
+      }
+    }
+    if (!hasValidA) badRanksB.add(rb);
+  }
+
+  if (badRanksA.size === 0 && badRanksB.size === 0) return null;
+
+  const elims = [
+    ...projectRanksToPositions(state, a, axis, badRanksA),
+    ...projectRanksToPositions(state, b, axis, badRanksB),
+  ];
+  const uniqueElims = dedup(elims);
+  if (uniqueElims.length === 0) return null;
+  for (const e of uniqueElims) getPossible(state, e.value).delete(e.position);
+  if (state.silent) return SILENT_STEP;
+  const assigns = collectAssigns(state, uniqueElims);
+  return step(
+    technique,
+    [ci],
+    uniqueElims,
+    assigns,
+    `${clueRef(ci)}${description} ${describeResult(state.grid, assigns, uniqueElims)}.`,
+  );
+}
+
 // --- Constraint deductions ---
 
 export function tryConstraint(
@@ -80,7 +154,7 @@ function tryAtPosition(
     [ci],
     elims,
     [{ value: c.value, position: c.position }],
-    `Clue ${ci + 1}: ${c.value} must be ${posPrep(state.grid)} the ${ordinal(c.position)} ${posNoun(state.grid)}.`,
+    `Clue ${ci + 1}: ${c.value} must be in the ${ordinal(c.position)} position.`,
   );
 }
 
@@ -97,14 +171,14 @@ function tryNotAtPosition(
     ps.size === 1 ? [{ value: c.value, position: first(ps) }] : [];
   const suffix =
     assigns.length > 0
-      ? `, so ${c.value} must be ${posPrep(state.grid)} the ${ordinal(assigns[0].position)} ${posNoun(state.grid)}.`
+      ? `, so ${c.value} must be in the ${ordinal(assigns[0].position)} position.`
       : ".";
   return step(
     "elimination",
     [ci],
     [{ value: c.value, position: c.position }],
     assigns,
-    `Clue ${ci + 1}: ${c.value} is not ${posPrep(state.grid)} the ${ordinal(c.position)} ${posNoun(state.grid)}${suffix}`,
+    `Clue ${ci + 1}: ${c.value} is not in the ${ordinal(c.position)} position${suffix}`,
   );
 }
 
@@ -143,8 +217,8 @@ function trySamePosition(
   const ctx = knownA || knownB;
   const because = ctx ? `. ${ctx}, so ` : ", so ";
 
-  const noun = posNoun(state.grid);
-  const prep = posPrep(state.grid);
+  const noun = "position";
+  const prep = "in";
   let explanation: string;
   if (assigns.length > 0) {
     explanation = `${clueRef(ci)}${c.a} and ${c.b} are ${prep} the same ${noun}${because}both are ${prep} the ${ordinal(assigns[0].position)} ${noun}.`;
@@ -180,8 +254,8 @@ function tryNotSamePosition(
   const pinned = posA !== null ? c.a : c.b;
   const pinnedPos = posA ?? posB!;
   const other = posA !== null ? c.b : c.a;
-  const noun = posNoun(state.grid);
-  const prep = posPrep(state.grid);
+  const noun = "position";
+  const prep = "in";
   const assignSuffix =
     assigns.length > 0
       ? ` ${assigns.map((a) => `${a.value} must be ${prep} the ${ordinal(a.position)} ${noun}`).join("; ")}.`
@@ -191,23 +265,49 @@ function tryNotSamePosition(
     [ci],
     elims,
     assigns,
-    `${clueRef(ci)}${pinned} and ${other} are ${prep} different ${posNounPlural(state.grid)}. ${pinned} is ${prep} the ${ordinal(pinnedPos)} ${noun}, so ${other} can't be there.${assignSuffix}`,
+    `${clueRef(ci)}${pinned} and ${other} are ${prep} different positions. ${pinned} is ${prep} the ${ordinal(pinnedPos)} ${noun}, so ${other} can't be there.${assignSuffix}`,
   );
 }
 
 function tryNextTo(
   state: DeduceState,
-  c: { a: string; b: string },
+  c: { a: string; b: string; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    return tryBinaryRankSpace(
+      state,
+      c.a,
+      c.b,
+      axis,
+      ci,
+      "next_to",
+      (ra, rb) => Math.abs(ra - rb) === 1,
+      `${c.a} is adjacent to ${c.b} on ${axis.name}.`,
+    );
+  }
   return tryAdjacency(state, c.a, c.b, ci, "next_to", true);
 }
 
 function tryNotNextTo(
   state: DeduceState,
-  c: { a: string; b: string },
+  c: { a: string; b: string; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    return tryBinaryRankSpace(
+      state,
+      c.a,
+      c.b,
+      axis,
+      ci,
+      "not_next_to",
+      (ra, rb) => Math.abs(ra - rb) !== 1,
+      `${c.a} is not adjacent to ${c.b} on ${axis.name}.`,
+    );
+  }
   return tryAdjacency(state, c.a, c.b, ci, "not_next_to", false);
 }
 
@@ -292,18 +392,29 @@ function tryAdjacency(
 
 function tryLeftOf(
   state: DeduceState,
-  c: { a: string; b: string },
+  c: { a: string; b: string; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    return tryBinaryRankSpace(
+      state,
+      c.a,
+      c.b,
+      axis,
+      ci,
+      "left_of",
+      (ra, rb) => rb === ra + 1,
+      `${c.a} is directly before ${c.b} on ${axis.name}.`,
+    );
+  }
   const pa = getPossible(state, c.a);
   const pb = getPossible(state, c.b);
   const elims: { value: string; position: number }[] = [];
 
-  // a is directly left of b: a can only be at p if b can be at p+1
   for (const p of pa) {
     if (!pb.has(p + 1)) elims.push({ value: c.a, position: p });
   }
-  // b can only be at p if a can be at p-1
   for (const p of pb) {
     if (!pa.has(p - 1)) elims.push({ value: c.b, position: p });
   }
@@ -328,14 +439,26 @@ function tryLeftOf(
 
 function tryBefore(
   state: DeduceState,
-  c: { a: string; b: string },
+  c: { a: string; b: string; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    return tryBinaryRankSpace(
+      state,
+      c.a,
+      c.b,
+      axis,
+      ci,
+      "before",
+      (ra, rb) => ra < rb,
+      `${c.a} is before ${c.b} on ${axis.name}.`,
+    );
+  }
   const pa = getPossible(state, c.a);
   const pb = getPossible(state, c.b);
   const elims: { value: string; position: number }[] = [];
 
-  // a must be left of b: eliminate positions for a where no valid b exists to the right
   if (pa.size === 0 || pb.size === 0) return null;
   const maxB = Math.max(...pb);
   for (const p of pa) {
@@ -366,9 +489,13 @@ function tryBefore(
 
 function tryBetween(
   state: DeduceState,
-  c: { outer1: string; middle: string; outer2: string },
+  c: { outer1: string; middle: string; outer2: string; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    return tryBetweenRankSpace(state, c, axis, ci, false);
+  }
   const po1 = getPossible(state, c.outer1);
   const pm = getPossible(state, c.middle);
   const po2 = getPossible(state, c.outer2);
@@ -453,8 +580,8 @@ function tryBetween(
 
   let because: string;
   if (a1 !== null && a2 !== null) {
-    const noun = posNoun(state.grid);
-    const prep = posPrep(state.grid);
+    const noun = "position";
+    const prep = "in";
     const parts = [
       `${c.outer1} is ${prep} the ${ordinal(a1)} ${noun}`,
       `${c.outer2} is ${prep} the ${ordinal(a2)} ${noun}`,
@@ -479,9 +606,13 @@ function tryBetween(
 
 function tryNotBetween(
   state: DeduceState,
-  c: { outer1: string; middle: string; outer2: string },
+  c: { outer1: string; middle: string; outer2: string; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    return tryBetweenRankSpace(state, c, axis, ci, true);
+  }
   const a1 = getAssigned(state, c.outer1);
   const a2 = getAssigned(state, c.outer2);
   const pm = getPossible(state, c.middle);
@@ -533,8 +664,8 @@ function tryNotBetween(
 
   let because: string;
   if (a1 !== null && a2 !== null) {
-    const noun = posNoun(state.grid);
-    const prep = posPrep(state.grid);
+    const noun = "position";
+    const prep = "in";
     because = ` ${c.outer1} is ${prep} the ${ordinal(a1)} ${noun} and ${c.outer2} is ${prep} the ${ordinal(a2)} ${noun}, so `;
   } else {
     // At least one outer always has a description for supported grid sizes (3–8):
@@ -552,16 +683,132 @@ function tryNotBetween(
   );
 }
 
+/**
+ * Rank-space deduction for between / not_between on non-identity-pinned axes.
+ */
+function tryBetweenRankSpace(
+  state: DeduceState,
+  c: { outer1: string; middle: string; outer2: string; axis: string },
+  axis: Category,
+  ci: number,
+  isNotBetween: boolean,
+): DeductionStep | null {
+  const technique: DeductionTechnique = isNotBetween
+    ? "not_between"
+    : "between";
+  const rO1 = axisRankDomain(state, c.outer1, axis);
+  const rO2 = axisRankDomain(state, c.outer2, axis);
+  const rM = axisRankDomain(state, c.middle, axis);
+  if (rO1.size === 0 || rO2.size === 0 || rM.size === 0) return null;
+
+  // For `between`: middle rank must be strictly between the two outers.
+  // Eliminate middle ranks where no valid outer pair exists on both sides.
+  // For `not_between`: middle rank must NOT be strictly between.
+  const badM = new Set<number>();
+  for (const rm of rM) {
+    let ok = false;
+    for (const r1 of rO1) {
+      for (const r2 of rO2) {
+        const lo = Math.min(r1, r2);
+        const hi = Math.max(r1, r2);
+        const isBetween = r1 !== r2 && rm > lo && rm < hi;
+        if (isNotBetween ? !isBetween : isBetween) {
+          ok = true;
+          break;
+        }
+      }
+      if (ok) break;
+    }
+    if (!ok) badM.add(rm);
+  }
+
+  // Similarly eliminate outer ranks that can't participate in any valid triple.
+  const badO1 = new Set<number>();
+  for (const r1 of rO1) {
+    let ok = false;
+    for (const r2 of rO2) {
+      for (const rm of rM) {
+        const lo = Math.min(r1, r2);
+        const hi = Math.max(r1, r2);
+        const isBetween = r1 !== r2 && rm > lo && rm < hi;
+        if (isNotBetween ? !isBetween : isBetween) {
+          ok = true;
+          break;
+        }
+      }
+      if (ok) break;
+    }
+    if (!ok) badO1.add(r1);
+  }
+  const badO2 = new Set<number>();
+  for (const r2 of rO2) {
+    let ok = false;
+    for (const r1 of rO1) {
+      for (const rm of rM) {
+        const lo = Math.min(r1, r2);
+        const hi = Math.max(r1, r2);
+        const isBetween = r1 !== r2 && rm > lo && rm < hi;
+        if (isNotBetween ? !isBetween : isBetween) {
+          ok = true;
+          break;
+        }
+      }
+      if (ok) break;
+    }
+    if (!ok) badO2.add(r2);
+  }
+
+  if (badM.size === 0 && badO1.size === 0 && badO2.size === 0) return null;
+
+  const elims = [
+    ...projectRanksToPositions(state, c.middle, axis, badM),
+    ...projectRanksToPositions(state, c.outer1, axis, badO1),
+    ...projectRanksToPositions(state, c.outer2, axis, badO2),
+  ];
+  const uniqueElims = dedup(elims);
+  if (uniqueElims.length === 0) return null;
+  for (const e of uniqueElims) getPossible(state, e.value).delete(e.position);
+  if (state.silent) return SILENT_STEP;
+  const assigns = collectAssigns(state, uniqueElims);
+  const verb = isNotBetween ? "is not between" : "is between";
+  return step(
+    technique,
+    [ci],
+    uniqueElims,
+    assigns,
+    `${clueRef(ci)}${c.middle} ${verb} ${c.outer1} and ${c.outer2} on ${axis.name}. ${describeResult(state.grid, assigns, uniqueElims)}.`,
+  );
+}
+
 function tryExactDistance(
   state: DeduceState,
-  c: { a: string; b: string; distance: number },
+  c: { a: string; b: string; distance: number; axis: string },
   ci: number,
 ): DeductionStep | null {
+  const axis = resolveAxis(state.grid, c.axis);
+  if (!isIdentityPinned(state.grid, axis)) {
+    const numVals = axis.numericValues;
+    return tryBinaryRankSpace(
+      state,
+      c.a,
+      c.b,
+      axis,
+      ci,
+      "exact_distance",
+      (ra, rb) => {
+        const d = numVals
+          ? Math.abs(numVals[ra] - numVals[rb])
+          : Math.abs(ra - rb);
+        return d === c.distance;
+      },
+      `${c.a} and ${c.b} are ${c.distance} apart on ${axis.name}.`,
+    );
+  }
   const n = state.n;
   const pa = getPossible(state, c.a);
   const pb = getPossible(state, c.b);
   const elims: { value: string; position: number }[] = [];
-  const numVals = findPositionCategory(state.grid)?.numericValues;
+  const numVals = axis.numericValues;
 
   if (numVals) {
     // Value-based distance: compute valid partner positions from numeric values
@@ -601,10 +848,10 @@ function tryExactDistance(
   for (const e of uniqueElims) getPossible(state, e.value).delete(e.position);
   if (state.silent) return SILENT_STEP;
   const assigns = collectAssigns(state, uniqueElims);
-  const unit = state.grid.spatialWords.distanceUnit;
+  const unit = axis.orderingPhrases.unit;
   const distLabel = unit
     ? `${c.distance} ${c.distance === 1 ? unit[0] : unit[1]}`
-    : `${c.distance} ${c.distance === 1 ? posNoun(state.grid) : posNounPlural(state.grid)}`;
+    : `${c.distance} ${c.distance === 1 ? "position" : "positions"}`;
   // At least one value always has a description for supported grid sizes (3–8).
   const ctx = describeKnown(state, c.a) || describeKnown(state, c.b);
   const because = ` ${ctx}, so `;
diff --git a/packages/logic-grid/src/deduce/contradiction.ts b/packages/logic-grid/src/deduce/contradiction.ts
index 2cf5de0..53b9b61 100644
--- a/packages/logic-grid/src/deduce/contradiction.ts
+++ b/packages/logic-grid/src/deduce/contradiction.ts
@@ -1,5 +1,5 @@
 import type { Constraint, DeductionStep } from "../types";
-import { ordinal, posNoun, posPrep } from "../grid-utils";
+import { ordinal } from "../grid-utils";
 import { type DeduceState, first, step, cloneState } from "./state";
 import { propagateToFixpoint } from "./propagate";
 
@@ -32,8 +32,8 @@ export function tryContradiction(
           ps.delete(p);
           const value = state.grid.categories[ci].values[vi];
           const assigns = ps.size === 1 ? [{ value, position: first(ps) }] : [];
-          const noun = posNoun(state.grid);
-          const prep = posPrep(state.grid);
+          const noun = "position";
+          const prep = "in";
           const assignSuffix =
             assigns.length > 0
               ? ` So ${value} must be ${prep} the ${ordinal(assigns[0].position)} ${noun}.`
diff --git a/packages/logic-grid/src/deduce/index.test.ts b/packages/logic-grid/src/deduce/index.test.ts
index 5e635ee..025fa33 100644
--- a/packages/logic-grid/src/deduce/index.test.ts
+++ b/packages/logic-grid/src/deduce/index.test.ts
@@ -44,7 +44,7 @@ const grid3x3 = makeGrid({
 const puzzle3x3: Constraint[] = [
   { type: "at_position", value: "Red", position: 0 },
   { type: "same_position", a: "Red", b: "Cat" },
-  { type: "left_of", a: "Blue", b: "Green" },
+  { type: "left_of", a: "Blue", b: "Green", axis: "House" },
   { type: "same_position", a: "Blue", b: "Dog" },
   { type: "same_position", a: "Dog", b: "Coffee" },
   { type: "at_position", value: "Tea", position: 0 },
diff --git a/packages/logic-grid/src/deduce/propagate.test.ts b/packages/logic-grid/src/deduce/propagate.test.ts
index 7a20a69..f26b16e 100644
--- a/packages/logic-grid/src/deduce/propagate.test.ts
+++ b/packages/logic-grid/src/deduce/propagate.test.ts
@@ -75,7 +75,7 @@ describe("propagateToFixpoint", () => {
     const state = createState(grid4);
     propagateToFixpoint(state, [
       { type: "at_position", value: "Red", position: 1 },
-      { type: "not_next_to", a: "Red", b: "Alice" },
+      { type: "not_next_to", a: "Red", b: "Alice", axis: "House" },
     ]);
     expect(getPossible(state, "Alice").has(2)).toBe(false);
   });
@@ -85,7 +85,7 @@ describe("propagateToFixpoint", () => {
     const state = createState(grid4);
     propagateToFixpoint(state, [
       { type: "at_position", value: "Alice", position: 2 },
-      { type: "not_next_to", a: "Red", b: "Alice" },
+      { type: "not_next_to", a: "Red", b: "Alice", axis: "House" },
     ]);
     expect(getPossible(state, "Red").has(1)).toBe(false);
   });
@@ -98,7 +98,7 @@ describe("propagateToFixpoint", () => {
       { type: "not_at_position", value: "Red", position: 1 },
       { type: "not_at_position", value: "Red", position: 2 },
       { type: "not_at_position", value: "Red", position: 3 },
-      { type: "not_next_to", a: "Red", b: "Alice" },
+      { type: "not_next_to", a: "Red", b: "Alice", axis: "House" },
     ];
     propagateToFixpoint(state, constraints);
     expect(getPossible(state, "Alice").has(1)).toBe(false);
@@ -111,7 +111,7 @@ describe("propagateToFixpoint", () => {
     propagateToFixpoint(state, [
       { type: "not_at_position", value: "Red", position: 1 },
       { type: "not_at_position", value: "Red", position: 3 },
-      { type: "not_next_to", a: "Red", b: "Alice" },
+      { type: "not_next_to", a: "Red", b: "Alice", axis: "House" },
     ]);
     expect(getPossible(state, "Alice").has(1)).toBe(false);
   });
@@ -122,7 +122,13 @@ describe("propagateToFixpoint", () => {
     propagateToFixpoint(state, [
       { type: "at_position", value: "Red", position: 0 },
       { type: "at_position", value: "Blue", position: 3 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ]);
     expect(getPossible(state, "Alice").has(1)).toBe(false);
     expect(getPossible(state, "Alice").has(2)).toBe(false);
@@ -134,7 +140,13 @@ describe("propagateToFixpoint", () => {
     propagateToFixpoint(state, [
       { type: "at_position", value: "Red", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ]);
     expect(getPossible(state, "Alice").has(1)).toBe(false);
   });
@@ -149,7 +161,13 @@ describe("propagateToFixpoint", () => {
       { type: "not_at_position", value: "Blue", position: 0 },
       { type: "not_at_position", value: "Blue", position: 1 },
       { type: "not_at_position", value: "Blue", position: 2 },
-      { type: "not_between", outer1: "Red", middle: "Alice", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Alice",
+        outer2: "Blue",
+        axis: "House",
+      },
     ]);
     expect(getPossible(state, "Alice").has(2)).toBe(false);
   });
diff --git a/packages/logic-grid/src/deduce/state.test.ts b/packages/logic-grid/src/deduce/state.test.ts
index 43b0d5e..9f054be 100644
--- a/packages/logic-grid/src/deduce/state.test.ts
+++ b/packages/logic-grid/src/deduce/state.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { describeResult, describeKnown, createState } from "./state";
 import { makeGrid } from "../test-helpers";
 
-const defaultGrid = makeGrid({
+const grid = makeGrid({
   size: 3,
   categories: [
     { name: "Name", values: ["Alice", "Bob", "Carol"] },
@@ -10,80 +10,60 @@ const defaultGrid = makeGrid({
   ],
 });
 
-const seatGrid = makeGrid({
-  size: 3,
-  categories: [
-    { name: "Name", values: ["Alice", "Bob", "Carol"] },
-    { name: "Color", values: ["Red", "Blue", "Green"] },
-  ],
-  positionNoun: ["seat", "seats"],
-  positionPreposition: "at",
-});
-
 describe("describeResult", () => {
-  it("uses default house/in when no custom noun", () => {
-    const result = describeResult(
-      defaultGrid,
-      [{ value: "Alice", position: 0 }],
-      [],
-    );
-    expect(result).toBe("Alice must be in the first house");
+  it("describes assignments", () => {
+    const result = describeResult(grid, [{ value: "Alice", position: 0 }], []);
+    expect(result).toBe("Alice must be in the first position");
   });
 
-  it("uses custom noun and preposition for assignments", () => {
-    const result = describeResult(
-      seatGrid,
-      [{ value: "Alice", position: 0 }],
-      [],
-    );
-    expect(result).toBe("Alice must be at the first seat");
-  });
-
-  it("uses custom noun and preposition for eliminations", () => {
-    const result = describeResult(
-      seatGrid,
-      [],
-      [{ value: "Bob", position: 1 }],
-    );
-    expect(result).toBe("Bob can't be at the second seat");
+  it("describes eliminations", () => {
+    const result = describeResult(grid, [], [{ value: "Bob", position: 1 }]);
+    expect(result).toBe("Bob can't be in the second position");
   });
 
-  it("combines assignments and eliminations with custom noun", () => {
+  it("combines assignments and eliminations", () => {
     const result = describeResult(
-      seatGrid,
+      grid,
       [{ value: "Alice", position: 0 }],
       [{ value: "Bob", position: 2 }],
     );
     expect(result).toBe(
-      "Alice must be at the first seat; Bob can't be at the third seat",
+      "Alice must be in the first position; Bob can't be in the third position",
     );
   });
 });
 
-describe("describeKnown", () => {
-  it("uses default house/in for assigned value", () => {
-    const state = createState(defaultGrid);
-    // Pin Alice to position 0
-    state.possible[0][0].clear();
-    state.possible[0][0].add(0);
-    expect(describeKnown(state, "Alice")).toBe("Alice is in the first house");
+describe("createState invariant", () => {
+  it("throws when grid has no ordered category", () => {
+    const bare = {
+      size: 3,
+      categories: [
+        { name: "A", values: ["a1", "a2", "a3"] },
+        { name: "B", values: ["b1", "b2", "b3"] },
+      ],
+    };
+    expect(() => createState(bare)).toThrow("no ordered category");
   });
+});
 
-  it("uses custom noun and preposition for assigned value", () => {
-    const state = createState(seatGrid);
-    state.possible[0][0].clear();
-    state.possible[0][0].add(0);
-    expect(describeKnown(state, "Alice")).toBe("Alice is at the first seat");
+describe("describeKnown", () => {
+  // makeGrid auto-prepends a House category; Name is now categories[1].
+  it("describes assigned value", () => {
+    const state = createState(grid);
+    state.possible[1][0].clear();
+    state.possible[1][0].add(0);
+    expect(describeKnown(state, "Alice")).toBe(
+      "Alice is in the first position",
+    );
   });
 
-  it("uses custom noun for possible positions", () => {
-    const state = createState(seatGrid);
-    // Restrict Bob to positions 0 and 2
-    state.possible[0][1].clear();
-    state.possible[0][1].add(0);
-    state.possible[0][1].add(2);
+  it("describes possible positions", () => {
+    const state = createState(grid);
+    state.possible[1][1].clear();
+    state.possible[1][1].add(0);
+    state.possible[1][1].add(2);
     expect(describeKnown(state, "Bob")).toBe(
-      "Bob can only be at the first or third seat",
+      "Bob can only be in the first or third position",
     );
   });
 });
diff --git a/packages/logic-grid/src/deduce/state.ts b/packages/logic-grid/src/deduce/state.ts
index 2262632..5eb60f6 100644
--- a/packages/logic-grid/src/deduce/state.ts
+++ b/packages/logic-grid/src/deduce/state.ts
@@ -1,15 +1,20 @@
-import type { Grid, DeductionStep, DeductionTechnique } from "../types";
-import { ordinal, posNoun, posPrep } from "../grid-utils";
+import type {
+  Category,
+  Grid,
+  DeductionStep,
+  DeductionTechnique,
+} from "../types";
+import { ordinal } from "../grid-utils";
 
 // --- Display utilities ---
 
 export function describeResult(
-  grid: Grid,
+  _grid: Grid,
   assigns: { value: string; position: number }[],
   elims: { value: string; position: number }[],
 ): string {
-  const noun = posNoun(grid);
-  const prep = posPrep(grid);
+  const noun = "position";
+  const prep = "in";
   const parts: string[] = [];
   for (const a of assigns) {
     parts.push(`${a.value} must be ${prep} the ${ordinal(a.position)} ${noun}`);
@@ -35,9 +40,8 @@ export function clueRef(ci: number): string {
 
 /** Describe what we know about a value's position — used for "because" context. */
 export function describeKnown(state: DeduceState, value: string): string {
-  const { grid } = state;
-  const noun = posNoun(grid);
-  const prep = posPrep(grid);
+  const noun = "position";
+  const prep = "in";
   const pos = getAssigned(state, value);
   if (pos !== null) return `${value} is ${prep} the ${ordinal(pos)} ${noun}`;
   const possible = getPossible(state, value);
@@ -82,6 +86,15 @@ export function createState(grid: Grid): DeduceState {
       valueInfo.set(grid.categories[ci].values[vi], [ci, vi]);
     }
   }
+  // Identity-pin the first ordered category to match randomSolution and
+  // encodeBase behavior.
+  const firstOrderedIdx = grid.categories.findIndex((c) => c.ordered === true);
+  if (firstOrderedIdx < 0) throw new Error("Grid has no ordered category");
+  const pinCat = grid.categories[firstOrderedIdx];
+  for (let vi = 0; vi < pinCat.values.length; vi++) {
+    possible[firstOrderedIdx][vi].clear();
+    possible[firstOrderedIdx][vi].add(vi);
+  }
   return { grid, n, possible, valueInfo, silent: false };
 }
 
@@ -160,3 +173,58 @@ export function collectAssigns(
   }
   return assigns;
 }
+
+// --- Rank-space helpers for multi-axis deduction ---
+
+/**
+ * Compute the set of ranks `value` could occupy on `axis`. A rank k is
+ * possible iff there exists a position p where both `value` and
+ * `axis.values[k]` are currently possible.
+ */
+export function axisRankDomain(
+  state: DeduceState,
+  value: string,
+  axis: Category,
+): Set<number> {
+  const ps = getPossible(state, value);
+  const ranks = new Set<number>();
+  for (const p of ps) {
+    for (let k = 0; k < axis.values.length; k++) {
+      if (getPossible(state, axis.values[k]).has(p)) {
+        ranks.add(k);
+      }
+    }
+  }
+  return ranks;
+}
+
+/**
+ * Project rank eliminations back to position eliminations. For each position
+ * currently possible for `value`, if the ONLY axis rank still possible at
+ * that position is in `eliminatedRanks`, then that position is eliminated.
+ */
+export function projectRanksToPositions(
+  state: DeduceState,
+  value: string,
+  axis: Category,
+  eliminatedRanks: Set<number>,
+): { value: string; position: number }[] {
+  const elims: { value: string; position: number }[] = [];
+  const ps = getPossible(state, value);
+  for (const p of ps) {
+    // Find all axis ranks still possible at position p.
+    let allEliminated = true;
+    for (let k = 0; k < axis.values.length; k++) {
+      if (getPossible(state, axis.values[k]).has(p)) {
+        if (!eliminatedRanks.has(k)) {
+          allEliminated = false;
+          break;
+        }
+      }
+    }
+    if (allEliminated) {
+      elims.push({ value, position: p });
+    }
+  }
+  return elims;
+}
diff --git a/packages/logic-grid/src/deduce/structural.test.ts b/packages/logic-grid/src/deduce/structural.test.ts
index f24a5a5..532b8ee 100644
--- a/packages/logic-grid/src/deduce/structural.test.ts
+++ b/packages/logic-grid/src/deduce/structural.test.ts
@@ -224,8 +224,8 @@ describe("deduce structural techniques", () => {
       ],
     });
     const constraints: Constraint[] = [
-      { type: "not_next_to", a: "Bob", b: "Green" },
-      { type: "left_of", a: "Carol", b: "Blue" },
+      { type: "not_next_to", a: "Bob", b: "Green", axis: "House" },
+      { type: "left_of", a: "Carol", b: "Blue", axis: "House" },
       { type: "same_position", a: "Carol", b: "Fish" },
       { type: "same_position", a: "Red", b: "Dog" },
     ];
diff --git a/packages/logic-grid/src/deduce/structural.ts b/packages/logic-grid/src/deduce/structural.ts
index 0188d0c..2c64839 100644
--- a/packages/logic-grid/src/deduce/structural.ts
+++ b/packages/logic-grid/src/deduce/structural.ts
@@ -1,5 +1,5 @@
 import type { DeductionStep } from "../types";
-import { ordinal, posNoun, posNounPlural, posPrep } from "../grid-utils";
+import { ordinal } from "../grid-utils";
 import {
   type DeduceState,
   SILENT_STEP,
@@ -43,7 +43,7 @@ export function tryNakedSingles(state: DeduceState): DeductionStep | null {
         [],
         elims,
         assigns,
-        `${cat.values[vi]} has no other possible position — it must be ${posPrep(state.grid)} the ${ordinal(pos)} ${posNoun(state.grid)}. So no other ${cat.name} can be there.`,
+        `${cat.values[vi]} has no other possible position — it must be in the ${ordinal(pos)} position. So no other ${cat.name} can be there.`,
       );
     }
   }
@@ -77,7 +77,7 @@ export function tryHiddenSingles(state: DeduceState): DeductionStep | null {
         [],
         elims,
         [{ value: val, position: p }],
-        `The ${ordinal(p)} ${posNoun(state.grid)} must be ${val} (only remaining ${cat.name}).`,
+        `The ${ordinal(p)} position must be ${val} (only remaining ${cat.name}).`,
       );
     }
   }
@@ -136,7 +136,7 @@ export function tryNakedPairs(state: DeduceState): DeductionStep | null {
           [],
           elims,
           assigns,
-          `${cat.values[vi1]} and ${cat.values[vi2]} can only be ${posPrep(state.grid)} the ${positions} ${posNounPlural(state.grid)}, so no other ${cat.name} can be there.`,
+          `${cat.values[vi1]} and ${cat.values[vi2]} can only be in the ${positions} positions, so no other ${cat.name} can be there.`,
         );
       }
     }
@@ -187,7 +187,7 @@ export function tryNakedTriples(state: DeduceState): DeductionStep | null {
             [],
             elims,
             assigns,
-            `${cat.values[vi1]}, ${cat.values[vi2]}, and ${cat.values[vi3]} can only be ${posPrep(state.grid)} the ${positions} ${posNounPlural(state.grid)}, so no other ${cat.name} can be there.`,
+            `${cat.values[vi1]}, ${cat.values[vi2]}, and ${cat.values[vi3]} can only be in the ${positions} positions, so no other ${cat.name} can be there.`,
           );
         }
       }
@@ -236,7 +236,7 @@ export function tryHiddenPairs(state: DeduceState): DeductionStep | null {
           [],
           uniqueElims,
           assigns,
-          `${cat.values[vi1]} and ${cat.values[vi2]} are the only ${cat.name} values for the ${ordinal(p1)} and ${ordinal(p2)} ${posNounPlural(state.grid)}, so they must be restricted to those positions.`,
+          `${cat.values[vi1]} and ${cat.values[vi2]} are the only ${cat.name} values for the ${ordinal(p1)} and ${ordinal(p2)} positions, so they must be restricted to those positions.`,
         );
       }
     }
@@ -285,7 +285,7 @@ export function tryHiddenTriples(state: DeduceState): DeductionStep | null {
             [],
             uniqueElims,
             assigns,
-            `${cat.values[vi1]}, ${cat.values[vi2]}, and ${cat.values[vi3]} are the only ${cat.name} values for the ${ordinal(p1)}, ${ordinal(p2)}, and ${ordinal(p3)} ${posNounPlural(state.grid)}, so they must be restricted to those positions.`,
+            `${cat.values[vi1]}, ${cat.values[vi2]}, and ${cat.values[vi3]} are the only ${cat.name} values for the ${ordinal(p1)}, ${ordinal(p2)}, and ${ordinal(p3)} positions, so they must be restricted to those positions.`,
           );
         }
       }
diff --git a/packages/logic-grid/src/default-config.ts b/packages/logic-grid/src/default-config.ts
index 67737be..934e809 100644
--- a/packages/logic-grid/src/default-config.ts
+++ b/packages/logic-grid/src/default-config.ts
@@ -1,146 +1,156 @@
-import type { Grid } from "./types";
+import type { Category } from "./types";
 
-/** Complete default grid configuration for the classic Einstein's riddle style. */
-export const DEFAULT_CONFIG: Omit<Grid, "size" | "positionLabels"> = {
-  categories: [
-    {
-      name: "Name",
-      noun: "",
-      subjectPriority: 2,
-      values: [
-        "Alice",
-        "Bob",
-        "Carol",
-        "Dave",
-        "Eve",
-        "Frank",
-        "Grace",
-        "Hank",
-      ],
-    },
-    {
-      name: "Color",
-      noun: "house",
-      verb: ["lives in the", "does not live in the"],
-      subjectPriority: -1,
-      valueSuffix: "house",
-      positionAdjective: ["is", "is not"],
-      values: [
-        "Red",
-        "Blue",
-        "Green",
-        "Yellow",
-        "White",
-        "Orange",
-        "Purple",
-        "Pink",
-      ],
-    },
-    {
-      name: "Pet",
-      noun: "owner",
-      verb: ["owns the", "does not own the"],
-      subjectPriority: 1,
-      values: [
-        "Cat",
-        "Dog",
-        "Fish",
-        "Bird",
-        "Rabbit",
-        "Turtle",
-        "Hamster",
-        "Snake",
-      ],
-    },
-    {
-      name: "Drink",
-      noun: "drinker",
-      verb: ["drinks", "does not drink"],
-      subjectPriority: 1,
-      values: [
-        "Tea",
-        "Coffee",
-        "Water",
-        "Milk",
-        "Juice",
-        "Soda",
-        "Wine",
-        "Beer",
-      ],
-    },
-    {
-      name: "Food",
-      noun: "lover",
-      verb: ["eats", "does not eat"],
-      subjectPriority: 1,
-      values: [
-        "Pizza",
-        "Pasta",
-        "Sushi",
-        "Tacos",
-        "Salad",
-        "Steak",
-        "Curry",
-        "Soup",
-      ],
-    },
-    {
-      name: "Hobby",
-      noun: "enthusiast",
-      verb: ["enjoys", "does not enjoy"],
-      subjectPriority: 1,
-      values: [
-        "Reading",
-        "Painting",
-        "Knitting",
-        "Gardening",
-        "Photography",
-        "Origami",
-        "Pottery",
-        "Woodwork",
-      ],
-    },
-    {
-      name: "Music",
-      noun: "fan",
-      verb: ["listens to", "does not listen to"],
-      subjectPriority: 1,
-      values: [
-        "Jazz",
-        "Rock",
-        "Pop",
-        "Blues",
-        "Folk",
-        "Reggae",
-        "Metal",
-        "Punk",
-      ],
-    },
-    {
-      name: "Sport",
-      noun: "player",
-      verb: ["plays", "does not play"],
-      subjectPriority: 1,
-      values: [
-        "Soccer",
-        "Tennis",
-        "Golf",
-        "Baseball",
-        "Rugby",
-        "Cricket",
-        "Hockey",
-        "Basketball",
-      ],
-    },
-  ],
-  positionNoun: ["house", "houses"],
-  positionPreposition: "in",
-  spatialWords: {
-    verb: ["lives", "does not live"],
-    adjacency: "next to",
-    direction: ["left of", "right of"],
-    between: "somewhere between",
-    atPosition: ["lives in", "does not live in"],
-    cardinals: ["zero", "one", "two", "three", "four", "five", "six", "seven"],
+/**
+ * Default non-position category pool for the classic Einstein's riddle style.
+ * When the user provides no `categoryNames`, `buildGrid` slices from this pool.
+ * None of these are ordered — an ordered "House" category is auto-prepended
+ * by `buildGrid` when no ordered category is present.
+ */
+export const DEFAULT_CATEGORIES: Category[] = [
+  {
+    name: "Name",
+    noun: "",
+    subjectPriority: 2,
+    values: ["Alice", "Bob", "Carol", "Dave", "Eve", "Frank", "Grace", "Hank"],
+  },
+  {
+    name: "Color",
+    noun: "house",
+    verb: ["lives in the", "does not live in the"],
+    subjectPriority: -1,
+    valueSuffix: "house",
+    positionAdjective: ["is", "is not"],
+    values: [
+      "Red",
+      "Blue",
+      "Green",
+      "Yellow",
+      "White",
+      "Orange",
+      "Purple",
+      "Pink",
+    ],
   },
-};
+  {
+    name: "Pet",
+    noun: "owner",
+    verb: ["owns the", "does not own the"],
+    subjectPriority: 1,
+    values: [
+      "Cat",
+      "Dog",
+      "Fish",
+      "Bird",
+      "Rabbit",
+      "Turtle",
+      "Hamster",
+      "Snake",
+    ],
+  },
+  {
+    name: "Drink",
+    noun: "drinker",
+    verb: ["drinks", "does not drink"],
+    subjectPriority: 1,
+    values: ["Tea", "Coffee", "Water", "Milk", "Juice", "Soda", "Wine", "Beer"],
+  },
+  {
+    name: "Food",
+    noun: "lover",
+    verb: ["eats", "does not eat"],
+    subjectPriority: 1,
+    values: [
+      "Pizza",
+      "Pasta",
+      "Sushi",
+      "Tacos",
+      "Salad",
+      "Steak",
+      "Curry",
+      "Soup",
+    ],
+  },
+  {
+    name: "Hobby",
+    noun: "enthusiast",
+    verb: ["enjoys", "does not enjoy"],
+    subjectPriority: 1,
+    values: [
+      "Reading",
+      "Painting",
+      "Knitting",
+      "Gardening",
+      "Photography",
+      "Origami",
+      "Pottery",
+      "Woodwork",
+    ],
+  },
+  {
+    name: "Music",
+    noun: "fan",
+    verb: ["listens to", "does not listen to"],
+    subjectPriority: 1,
+    values: ["Jazz", "Rock", "Pop", "Blues", "Folk", "Reggae", "Metal", "Punk"],
+  },
+  {
+    name: "Sport",
+    noun: "player",
+    verb: ["plays", "does not play"],
+    subjectPriority: 1,
+    values: [
+      "Soccer",
+      "Tennis",
+      "Golf",
+      "Baseball",
+      "Rugby",
+      "Cricket",
+      "Hockey",
+      "Basketball",
+    ],
+  },
+];
+
+/**
+ * Build the auto-added House ordered category. Used by `buildGrid` when the
+ * user supplies no ordered category. noun + valueSuffix both set so label()
+ * yields "the first house" (subject form) and objectValue() yields "first
+ * house" (object form). Combined with the verb this renders
+ * `same_position(Alice, "first")` as "Alice lives in the first house" and
+ * `same_position(Red, "first")` (via the positionAdjective rule on Color) as
+ * "The first house is red" — recovering the classical rendering exactly.
+ */
+export function defaultHouseCategory(size: number): Category {
+  const ordinals = [
+    "first",
+    "second",
+    "third",
+    "fourth",
+    "fifth",
+    "sixth",
+    "seventh",
+    "eighth",
+  ];
+  return {
+    name: "House",
+    noun: "house",
+    verb: ["lives in the", "does not live in the"],
+    valueSuffix: "house",
+    ordered: true,
+    values: ordinals.slice(0, size),
+    // Grid headers show "1, 2, 3..." while clues use "first house, second house..."
+    displayLabels: Array.from({ length: size }, (_, i) => String(i + 1)),
+    orderingPhrases: {
+      unit: ["house", "houses"],
+      comparators: {
+        before: ["lives somewhere left of", "lives somewhere right of"],
+        left_of: ["lives directly left of", "lives directly right of"],
+        next_to: "lives next to",
+        not_next_to: "does not live next to",
+        between: "lives somewhere between",
+        not_between: "does not live somewhere between",
+        exact_distance: "lives exactly",
+      },
+    },
+  };
+}
diff --git a/packages/logic-grid/src/difficulty.test.ts b/packages/logic-grid/src/difficulty.test.ts
index 01214d4..f47563c 100644
--- a/packages/logic-grid/src/difficulty.test.ts
+++ b/packages/logic-grid/src/difficulty.test.ts
@@ -25,14 +25,14 @@ describe("classify by constraint types only", () => {
   it("returns medium when next_to is present", () => {
     const constraints: Constraint[] = [
       { type: "same_position", a: "Red", b: "Cat" },
-      { type: "next_to", a: "Blue", b: "Dog" },
+      { type: "next_to", a: "Blue", b: "Dog", axis: "House" },
     ];
     expect(classify(constraints)).toBe("medium");
   });
 
   it("returns medium when left_of is present", () => {
     const constraints: Constraint[] = [
-      { type: "left_of", a: "Red", b: "Blue" },
+      { type: "left_of", a: "Red", b: "Blue", axis: "House" },
     ];
     expect(classify(constraints)).toBe("medium");
   });
@@ -40,33 +40,53 @@ describe("classify by constraint types only", () => {
   it("returns hard when between is present", () => {
     const constraints: Constraint[] = [
       { type: "same_position", a: "Red", b: "Cat" },
-      { type: "between", outer1: "Red", middle: "Dog", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Dog",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     expect(classify(constraints)).toBe("hard");
   });
 
   it("returns medium when before is present", () => {
-    const constraints: Constraint[] = [{ type: "before", a: "Red", b: "Blue" }];
+    const constraints: Constraint[] = [
+      { type: "before", a: "Red", b: "Blue", axis: "House" },
+    ];
     expect(classify(constraints)).toBe("medium");
   });
 
   it("returns hard when not_next_to is present", () => {
     const constraints: Constraint[] = [
-      { type: "not_next_to", a: "Red", b: "Cat" },
+      { type: "not_next_to", a: "Red", b: "Cat", axis: "House" },
     ];
     expect(classify(constraints)).toBe("hard");
   });
 
   it("returns hard when not_between is present", () => {
     const constraints: Constraint[] = [
-      { type: "not_between", outer1: "Red", middle: "Cat", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Cat",
+        outer2: "Blue",
+        axis: "House",
+      },
     ];
     expect(classify(constraints)).toBe("hard");
   });
 
   it("returns hard when exact_distance is present", () => {
     const constraints: Constraint[] = [
-      { type: "exact_distance", a: "Red", b: "Cat", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Cat",
+        distance: 2,
+        axis: "House",
+      },
     ];
     expect(classify(constraints)).toBe("hard");
   });
@@ -116,18 +136,24 @@ describe("classify with grid (deduction depth)", () => {
 
   it("returns expert for medium types that require contradiction", () => {
     const constraints: Constraint[] = [
-      { type: "next_to", a: "Red", b: "Cat" },
-      { type: "next_to", a: "Red", b: "Dog" },
-      { type: "left_of", a: "Blue", b: "Tea" },
-      { type: "before", a: "Cat", b: "Coffee" },
+      { type: "next_to", a: "Red", b: "Cat", axis: "House" },
+      { type: "next_to", a: "Red", b: "Dog", axis: "House" },
+      { type: "left_of", a: "Blue", b: "Tea", axis: "House" },
+      { type: "before", a: "Cat", b: "Coffee", axis: "House" },
     ];
     expect(classify(constraints, grid3x3)).toBe("expert");
   });
 
   it("returns expert for hard types that require contradiction", () => {
     const constraints: Constraint[] = [
-      { type: "not_next_to", a: "Red", b: "Cat" },
-      { type: "exact_distance", a: "Blue", b: "Dog", distance: 2 },
+      { type: "not_next_to", a: "Red", b: "Cat", axis: "House" },
+      {
+        type: "exact_distance",
+        a: "Blue",
+        b: "Dog",
+        distance: 2,
+        axis: "House",
+      },
     ];
     expect(classify(constraints, grid3x3)).toBe("expert");
   });
diff --git a/packages/logic-grid/src/encoding.test.ts b/packages/logic-grid/src/encoding.test.ts
index dc1414c..451bd0e 100644
--- a/packages/logic-grid/src/encoding.test.ts
+++ b/packages/logic-grid/src/encoding.test.ts
@@ -1,8 +1,8 @@
 import { describe, it, expect } from "vitest";
 import { createContext, variable, encodeBase, encodePuzzle } from "./encoding";
 import { solveSAT, solveAllSAT } from "./sat";
-import { makeGrid } from "./test-helpers";
-import type { Constraint } from "./types";
+import { makeGrid, TEST_COMPARATORS } from "./test-helpers";
+import type { Constraint, Grid } from "./types";
 
 const grid3x3 = makeGrid({
   size: 3,
@@ -29,18 +29,21 @@ function decodeSolution(
   return result;
 }
 
+// 3x3 grid has 3 user categories + auto-added House = 4 categories, 12 values total.
+const NUM_VALUES_3X3 = 12;
+
 describe("createContext", () => {
   it("assigns unique indices to all values", () => {
     const ctx = createContext(grid3x3);
-    expect(ctx.valueIndex.size).toBe(9);
+    expect(ctx.valueIndex.size).toBe(NUM_VALUES_3X3);
     const indices = new Set(ctx.valueIndex.values());
-    expect(indices.size).toBe(9);
+    expect(indices.size).toBe(NUM_VALUES_3X3);
   });
 
   it("records correct dimensions", () => {
     const ctx = createContext(grid3x3);
     expect(ctx.numPositions).toBe(3);
-    expect(ctx.numValues).toBe(9);
+    expect(ctx.numValues).toBe(NUM_VALUES_3X3);
   });
 });
 
@@ -55,7 +58,7 @@ describe("variable", () => {
         vars.add(v);
       }
     }
-    expect(vars.size).toBe(27); // 9 values * 3 positions
+    expect(vars.size).toBe(NUM_VALUES_3X3 * 3);
   });
 
   it("throws for unknown value", () => {
@@ -151,7 +154,7 @@ describe("encodeConstraint", () => {
   it("next_to forces adjacency", () => {
     const ctx = createContext(grid3x3);
     const clauses = encodePuzzle(ctx, [
-      { type: "next_to", a: "Red", b: "Cat" },
+      { type: "next_to", a: "Red", b: "Cat", axis: "House" },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     expect(solutions.length).toBeGreaterThan(0);
@@ -164,7 +167,7 @@ describe("encodeConstraint", () => {
   it("not_next_to prevents adjacency", () => {
     const ctx = createContext(grid3x3);
     const clauses = encodePuzzle(ctx, [
-      { type: "not_next_to", a: "Red", b: "Cat" },
+      { type: "not_next_to", a: "Red", b: "Cat", axis: "House" },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     for (const sol of solutions) {
@@ -176,7 +179,7 @@ describe("encodeConstraint", () => {
   it("left_of places a immediately left of b", () => {
     const ctx = createContext(grid3x3);
     const clauses = encodePuzzle(ctx, [
-      { type: "left_of", a: "Red", b: "Cat" },
+      { type: "left_of", a: "Red", b: "Cat", axis: "House" },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     expect(solutions.length).toBeGreaterThan(0);
@@ -189,7 +192,13 @@ describe("encodeConstraint", () => {
   it("between forces middle between outers", () => {
     const ctx = createContext(grid3x3);
     const clauses = encodePuzzle(ctx, [
-      { type: "between", outer1: "Red", middle: "Cat", outer2: "Blue" },
+      {
+        type: "between",
+        outer1: "Red",
+        middle: "Cat",
+        outer2: "Blue",
+        axis: "House",
+      },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     expect(solutions.length).toBeGreaterThan(0);
@@ -205,7 +214,13 @@ describe("encodeConstraint", () => {
   it("not_between forbids middle between outers", () => {
     const ctx = createContext(grid3x3);
     const clauses = encodePuzzle(ctx, [
-      { type: "not_between", outer1: "Red", middle: "Cat", outer2: "Blue" },
+      {
+        type: "not_between",
+        outer1: "Red",
+        middle: "Cat",
+        outer2: "Blue",
+        axis: "House",
+      },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     for (const sol of solutions) {
@@ -220,7 +235,9 @@ describe("encodeConstraint", () => {
 
   it("before forces a to be left of b", () => {
     const ctx = createContext(grid3x3);
-    const clauses = encodePuzzle(ctx, [{ type: "before", a: "Red", b: "Cat" }]);
+    const clauses = encodePuzzle(ctx, [
+      { type: "before", a: "Red", b: "Cat", axis: "House" },
+    ]);
     const solutions = solveAllSAT(clauses, 100);
     expect(solutions.length).toBeGreaterThan(0);
     for (const sol of solutions) {
@@ -232,7 +249,13 @@ describe("encodeConstraint", () => {
   it("exact_distance forces exact position difference", () => {
     const ctx = createContext(grid3x3);
     const clauses = encodePuzzle(ctx, [
-      { type: "exact_distance", a: "Red", b: "Cat", distance: 2 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Cat",
+        distance: 2,
+        axis: "House",
+      },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     expect(solutions.length).toBeGreaterThan(0);
@@ -251,27 +274,33 @@ describe("encodeConstraint", () => {
           name: "Year",
           values: ["1980", "1990", "2005"],
           noun: "car",
-          isPosition: true,
+          verb: ["drives the", "does not drive the"],
+          ordered: true,
           numericValues: [1980, 1990, 2005],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
     const ctx = createContext(numGrid);
     // distance=10 means |numericValues[p1]-numericValues[p2]|=10, i.e. positions 0,1
     const clauses = encodePuzzle(ctx, [
-      { type: "exact_distance", a: "Red", b: "Blue", distance: 10 },
+      {
+        type: "exact_distance",
+        a: "Red",
+        b: "Blue",
+        distance: 10,
+        axis: "Year",
+      },
     ]);
     const solutions = solveAllSAT(clauses, 100);
     expect(solutions.length).toBeGreaterThan(0);
+    const yearCat = numGrid.categories.find((c) => c.name === "Year")!;
     for (const sol of solutions) {
       const decoded = decodeSolution(ctx, sol);
       const p1 = decoded["Red"];
       const p2 = decoded["Blue"];
       expect(
-        Math.abs(
-          numGrid.categories[1].numericValues![p1] -
-            numGrid.categories[1].numericValues![p2],
-        ),
+        Math.abs(yearCat.numericValues![p1] - yearCat.numericValues![p2]),
       ).toBe(10);
     }
   });
@@ -304,3 +333,241 @@ describe("encodeConstraint", () => {
     expect(decoded["Water"]).toBe(2);
   });
 });
+
+describe("encodeBase invariant", () => {
+  it("throws when grid has no ordered category", () => {
+    const bare: Grid = {
+      size: 3,
+      categories: [
+        { name: "A", values: ["a1", "a2", "a3"] },
+        { name: "B", values: ["b1", "b2", "b3"] },
+      ],
+    };
+    const ctx = createContext(bare);
+    expect(() => encodeBase(ctx)).toThrow("no ordered category");
+  });
+});
+
+// Multi-axis encoder tests: exercise the rank-forbidding path on a
+// non-identity-pinned axis. Year is declared before Return so Year is the
+// first ordered category (identity-pinned), and Return is the second ordered
+// category (not pinned) — forcing the rank-forbidding path when constraints
+// reference "Return".
+describe("encodeConstraint on non-pinned ordered axis", () => {
+  const multiGrid = makeGrid({
+    size: 4,
+    categories: [
+      { name: "Name", values: ["Alice", "Bob", "Carol", "Dan"], noun: "" },
+      {
+        name: "Year",
+        values: ["2020", "2021", "2022", "2023"],
+        noun: "fund",
+        verb: ["was begun in", "was not begun in"],
+        ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
+      },
+      {
+        name: "Return",
+        values: ["5%", "6%", "7%", "8%"],
+        noun: "fund",
+        verb: ["has a return of", "does not have a return of"],
+        ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
+      },
+    ],
+  });
+  const returnValues = ["5%", "6%", "7%", "8%"];
+
+  /** Given a SAT solution, find `name`'s rank on the Return axis. */
+  function returnRank(decoded: Record<string, number>, name: string): number {
+    const p = decoded[name];
+    for (let k = 0; k < returnValues.length; k++) {
+      if (decoded[returnValues[k]] === p) return k;
+    }
+    throw new Error(`No Return value colocated with ${name}`);
+  }
+
+  it("before on non-pinned axis", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      { type: "before", a: "Alice", b: "Bob", axis: "Return" },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      expect(returnRank(decoded, "Alice")).toBeLessThan(
+        returnRank(decoded, "Bob"),
+      );
+    }
+  });
+
+  it("left_of on non-pinned axis", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      { type: "left_of", a: "Alice", b: "Bob", axis: "Return" },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      expect(returnRank(decoded, "Bob") - returnRank(decoded, "Alice")).toBe(1);
+    }
+  });
+
+  it("next_to on non-pinned axis", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      { type: "next_to", a: "Alice", b: "Bob", axis: "Return" },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      const diff = Math.abs(
+        returnRank(decoded, "Alice") - returnRank(decoded, "Bob"),
+      );
+      expect(diff).toBe(1);
+    }
+  });
+
+  it("not_next_to on non-pinned axis", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      { type: "not_next_to", a: "Alice", b: "Bob", axis: "Return" },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      const diff = Math.abs(
+        returnRank(decoded, "Alice") - returnRank(decoded, "Bob"),
+      );
+      expect(diff).not.toBe(1);
+    }
+  });
+
+  it("between on non-pinned axis", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      {
+        type: "between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "Return",
+      },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      const a = returnRank(decoded, "Alice");
+      const m = returnRank(decoded, "Bob");
+      const c = returnRank(decoded, "Carol");
+      const lo = Math.min(a, c);
+      const hi = Math.max(a, c);
+      expect(m).toBeGreaterThan(lo);
+      expect(m).toBeLessThan(hi);
+    }
+  });
+
+  it("not_between on non-pinned axis", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      {
+        type: "not_between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "Return",
+      },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      const a = returnRank(decoded, "Alice");
+      const m = returnRank(decoded, "Bob");
+      const c = returnRank(decoded, "Carol");
+      const lo = Math.min(a, c);
+      const hi = Math.max(a, c);
+      // Strictly between is forbidden; m may equal an outer or be outside.
+      expect(m <= lo || m >= hi).toBe(true);
+    }
+  });
+
+  it("exact_distance on non-pinned axis (rank steps)", () => {
+    const ctx = createContext(multiGrid);
+    const clauses = encodePuzzle(ctx, [
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Return",
+      },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      const diff = Math.abs(
+        returnRank(decoded, "Alice") - returnRank(decoded, "Bob"),
+      );
+      expect(diff).toBe(2);
+    }
+  });
+
+  it("exact_distance on non-pinned axis with numericValues", () => {
+    const numGrid = makeGrid({
+      size: 4,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol", "Dan"], noun: "" },
+        {
+          name: "Year",
+          values: ["2020", "2021", "2022", "2023"],
+          noun: "fund",
+          verb: ["was begun in", "was not begun in"],
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
+        {
+          name: "Return",
+          values: ["3%", "5%", "8%", "12%"],
+          noun: "fund",
+          verb: ["has a return of", "does not have a return of"],
+          ordered: true,
+          numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
+      ],
+    });
+    const ctx = createContext(numGrid);
+    const clauses = encodePuzzle(ctx, [
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 7,
+        axis: "Return",
+      },
+    ]);
+    const solutions = solveAllSAT(clauses, 50);
+    expect(solutions.length).toBeGreaterThan(0);
+    const numVals = [3, 5, 8, 12];
+    for (const sol of solutions) {
+      const decoded = decodeSolution(ctx, sol);
+      const rankValues = ["3%", "5%", "8%", "12%"];
+      const rank = (name: string): number => {
+        const p = decoded[name];
+        for (let k = 0; k < rankValues.length; k++) {
+          if (decoded[rankValues[k]] === p) return k;
+        }
+        throw new Error(`No Return value colocated with ${name}`);
+      };
+      const diff = Math.abs(numVals[rank("Alice")] - numVals[rank("Bob")]);
+      expect(diff).toBe(7);
+    }
+  });
+});
diff --git a/packages/logic-grid/src/encoding.ts b/packages/logic-grid/src/encoding.ts
index 9ff06bb..085c3f9 100644
--- a/packages/logic-grid/src/encoding.ts
+++ b/packages/logic-grid/src/encoding.ts
@@ -1,5 +1,169 @@
-import type { Constraint, Grid } from "./types";
-import { findPositionCategory } from "./grid-utils";
+import type { Category, Constraint, Grid } from "./types";
+import { resolveAxis } from "./axis";
+
+/**
+ * True when `axis` is the first ordered category in `grid`. This category is
+ * identity-pinned by encodeBase (rank = position), so the cheap positional
+ * encoders can be used for constraints targeting it.
+ */
+function isIdentityPinnedAxis(grid: Grid, axis: Category): boolean {
+  return grid.categories.find((c) => c.ordered === true) === axis;
+}
+
+/**
+ * Comparative constraint types for binary rank relations (a, b).
+ * `between` and `not_between` are ternary and handled separately.
+ */
+type BinaryComparativeType =
+  | "before"
+  | "left_of"
+  | "next_to"
+  | "not_next_to"
+  | "exact_distance";
+
+/**
+ * Enumerate "bad" rank pairs for a binary comparative — the (rank_a, rank_b)
+ * combinations that violate the constraint and must be forbidden.
+ */
+function badBinaryRankPairs(
+  type: BinaryComparativeType,
+  M: number,
+  distance: number,
+  numericValues: number[] | undefined,
+): [number, number][] {
+  const bad: [number, number][] = [];
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < M; j++) {
+      let violates: boolean;
+      switch (type) {
+        case "before":
+          violates = i >= j;
+          break;
+        case "left_of":
+          violates = j !== i + 1;
+          break;
+        case "next_to":
+          violates = Math.abs(i - j) !== 1;
+          break;
+        case "not_next_to":
+          violates = Math.abs(i - j) === 1;
+          break;
+        case "exact_distance": {
+          const d = numericValues
+            ? Math.abs(numericValues[i] - numericValues[j])
+            : Math.abs(i - j);
+          violates = d !== distance;
+          break;
+        }
+      }
+      if (violates) bad.push([i, j]);
+    }
+  }
+  return bad;
+}
+
+/**
+ * Rank-forbidding encoder for binary comparative constraints. For each bad
+ * rank pair (i, j) and each ordered position pair (p1, p2) with p1 ≠ p2,
+ * emits the 4-literal clause
+ *   [¬x(a, p1), ¬x(axis[i], p1), ¬x(b, p2), ¬x(axis[j], p2)]
+ * which forbids the simultaneous assignment.
+ *
+ * Clause count per constraint: |bad pairs| × n(n−1). Worst case O(M²·n²).
+ */
+function encodeBinaryAxis(
+  ctx: EncodingContext,
+  a: string,
+  b: string,
+  axis: Category,
+  badPairs: [number, number][],
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (const [i, j] of badPairs) {
+    const ai = axis.values[i];
+    const aj = axis.values[j];
+    for (let p1 = 0; p1 < n; p1++) {
+      for (let p2 = 0; p2 < n; p2++) {
+        // When i ≠ j and p1 = p2, base clauses forbid two distinct axis
+        // values coexisting at the same position, so the clause is vacuous.
+        // When i = j, we MUST emit the p1 = p2 case — it forbids `a` and
+        // `b` sharing the same position (and thus the same rank).
+        if (p1 === p2 && i !== j) continue;
+        clauses.push([
+          -variable(ctx, a, p1),
+          -variable(ctx, ai, p1),
+          -variable(ctx, b, p2),
+          -variable(ctx, aj, p2),
+        ]);
+      }
+    }
+  }
+  return clauses;
+}
+
+/**
+ * Rank-forbidding encoder for ternary between/not_between. For each bad
+ * (rank_o1, rank_o2, rank_middle) triple and each position triple (p1, p2, p3)
+ * with all positions distinct, emits a 6-literal clause forbidding the
+ * assignment.
+ *
+ * Complexity: O(M³·n³) worst case — ~260k clause candidates at M=n=8.
+ * Acceptable for the supported grid size range (3–8) but would need
+ * optimization (e.g. exploiting ALO/AMO redundancy) if the range expanded.
+ */
+function encodeBetweenAxis(
+  ctx: EncodingContext,
+  outer1: string,
+  middle: string,
+  outer2: string,
+  axis: Category,
+  forbidStrictlyBetween: boolean,
+): number[][] {
+  const n = ctx.numPositions;
+  const M = axis.values.length;
+  const clauses: number[][] = [];
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < M; j++) {
+      for (let k = 0; k < M; k++) {
+        const lo = Math.min(i, j);
+        const hi = Math.max(i, j);
+        // "strictly between" requires i ≠ j (non-degenerate outer pair) and
+        // k lies strictly inside the open interval (lo, hi).
+        const strictlyBetween = i !== j && k > lo && k < hi;
+        // `between` is violated when middle is NOT strictly between outers.
+        // `not_between` is violated when middle IS strictly between outers.
+        const violates = forbidStrictlyBetween
+          ? strictlyBetween
+          : !strictlyBetween;
+        if (!violates) continue;
+        const ai = axis.values[i];
+        const aj = axis.values[j];
+        const ak = axis.values[k];
+        for (let p1 = 0; p1 < n; p1++) {
+          for (let p2 = 0; p2 < n; p2++) {
+            // When i ≠ j and p1 = p2, a_i and a_j collide → vacuous.
+            if (p1 === p2 && i !== j) continue;
+            for (let p3 = 0; p3 < n; p3++) {
+              // Same vacuous-collision skips for the middle's axis slot.
+              if (p3 === p1 && k !== i) continue;
+              if (p3 === p2 && k !== j) continue;
+              clauses.push([
+                -variable(ctx, outer1, p1),
+                -variable(ctx, ai, p1),
+                -variable(ctx, outer2, p2),
+                -variable(ctx, aj, p2),
+                -variable(ctx, middle, p3),
+                -variable(ctx, ak, p3),
+              ]);
+            }
+          }
+        }
+      }
+    }
+  }
+  return clauses;
+}
 
 /** Holds grid metadata needed to map values/positions to SAT variables. */
 export interface EncodingContext {
@@ -80,216 +244,308 @@ export function encodeBase(ctx: EncodingContext): number[][] {
     }
   }
 
+  // Identity-pin the first ordered category. This matches the generator's
+  // randomSolution behavior and keeps the row-based positional encoder
+  // semantically consistent with the axis-tagged comparative constraints.
+  const firstOrdered = grid.categories.find((c) => c.ordered === true);
+  if (!firstOrdered) throw new Error("Grid has no ordered category");
+  for (let i = 0; i < firstOrdered.values.length; i++) {
+    clauses.push([variable(ctx, firstOrdered.values[i], i)]);
+  }
+
   return clauses;
 }
 
-/** Encode a single constraint as CNF clauses. */
-export function encodeConstraint(
+// --- Positional fast path for identity-pinned axes ---
+// The first ordered category is identity-pinned (value i at row i) by
+// encodeBase. For constraints targeting this axis, we can use direct
+// position-based clauses instead of the larger rank-forbidding clauses.
+
+function encodePositionalNextTo(
   ctx: EncodingContext,
-  constraint: Constraint,
+  a: string,
+  b: string,
 ): number[][] {
   const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (let p = 0; p < n; p++) {
+    const clause: number[] = [-variable(ctx, a, p)];
+    if (p > 0) clause.push(variable(ctx, b, p - 1));
+    if (p < n - 1) clause.push(variable(ctx, b, p + 1));
+    clauses.push(clause);
+  }
+  for (let p = 0; p < n; p++) {
+    const clause: number[] = [-variable(ctx, b, p)];
+    if (p > 0) clause.push(variable(ctx, a, p - 1));
+    if (p < n - 1) clause.push(variable(ctx, a, p + 1));
+    clauses.push(clause);
+  }
+  return clauses;
+}
 
-  switch (constraint.type) {
-    case "same_position": {
-      const { a, b } = constraint;
-      const clauses: number[][] = [];
-      for (let p = 0; p < n; p++) {
-        clauses.push([-variable(ctx, a, p), variable(ctx, b, p)]);
-        clauses.push([-variable(ctx, b, p), variable(ctx, a, p)]);
+function encodePositionalNotNextTo(
+  ctx: EncodingContext,
+  a: string,
+  b: string,
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (let p = 0; p < n - 1; p++) {
+    clauses.push([-variable(ctx, a, p), -variable(ctx, b, p + 1)]);
+    clauses.push([-variable(ctx, a, p + 1), -variable(ctx, b, p)]);
+  }
+  return clauses;
+}
+
+function encodePositionalLeftOf(
+  ctx: EncodingContext,
+  a: string,
+  b: string,
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (let p = 0; p < n - 1; p++) {
+    clauses.push([-variable(ctx, a, p), variable(ctx, b, p + 1)]);
+  }
+  for (let p = 1; p < n; p++) {
+    clauses.push([-variable(ctx, b, p), variable(ctx, a, p - 1)]);
+  }
+  clauses.push([-variable(ctx, a, n - 1)]);
+  clauses.push([-variable(ctx, b, 0)]);
+  return clauses;
+}
+
+function encodePositionalBefore(
+  ctx: EncodingContext,
+  a: string,
+  b: string,
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (let p = 0; p < n; p++) {
+    const clause: number[] = [-variable(ctx, a, p)];
+    for (let q = p + 1; q < n; q++) clause.push(variable(ctx, b, q));
+    clauses.push(clause);
+  }
+  for (let p = 0; p < n; p++) {
+    const clause: number[] = [-variable(ctx, b, p)];
+    for (let q = 0; q < p; q++) clause.push(variable(ctx, a, q));
+    clauses.push(clause);
+  }
+  return clauses;
+}
+
+function encodePositionalBetween(
+  ctx: EncodingContext,
+  outer1: string,
+  middle: string,
+  outer2: string,
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (let po1 = 0; po1 < n; po1++) {
+    for (let po2 = 0; po2 < n; po2++) {
+      if (po1 === po2) continue;
+      const lo = Math.min(po1, po2);
+      const hi = Math.max(po1, po2);
+      const validMiddle: number[] = [];
+      for (let pm = lo + 1; pm < hi; pm++) {
+        validMiddle.push(variable(ctx, middle, pm));
+      }
+      if (validMiddle.length === 0) {
+        clauses.push([
+          -variable(ctx, outer1, po1),
+          -variable(ctx, outer2, po2),
+        ]);
+      } else {
+        clauses.push([
+          -variable(ctx, outer1, po1),
+          -variable(ctx, outer2, po2),
+          ...validMiddle,
+        ]);
       }
-      return clauses;
     }
+  }
+  return clauses;
+}
 
-    case "not_same_position": {
-      const { a, b } = constraint;
-      const clauses: number[][] = [];
-      for (let p = 0; p < n; p++) {
-        clauses.push([-variable(ctx, a, p), -variable(ctx, b, p)]);
+function encodePositionalNotBetween(
+  ctx: EncodingContext,
+  outer1: string,
+  middle: string,
+  outer2: string,
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  for (let pm = 1; pm < n - 1; pm++) {
+    for (let po1 = 0; po1 < pm; po1++) {
+      for (let po2 = pm + 1; po2 < n; po2++) {
+        clauses.push([
+          -variable(ctx, middle, pm),
+          -variable(ctx, outer1, po1),
+          -variable(ctx, outer2, po2),
+        ]);
+        clauses.push([
+          -variable(ctx, middle, pm),
+          -variable(ctx, outer1, po2),
+          -variable(ctx, outer2, po1),
+        ]);
       }
-      return clauses;
     }
+  }
+  return clauses;
+}
 
-    case "next_to": {
-      const { a, b } = constraint;
-      const clauses: number[][] = [];
-      // If a at p, then b at p-1 or p+1
-      for (let p = 0; p < n; p++) {
-        const clause: number[] = [-variable(ctx, a, p)];
-        if (p > 0) clause.push(variable(ctx, b, p - 1));
-        if (p < n - 1) clause.push(variable(ctx, b, p + 1));
-        clauses.push(clause);
+function encodePositionalExactDistance(
+  ctx: EncodingContext,
+  a: string,
+  b: string,
+  distance: number,
+  numVals: number[] | undefined,
+): number[][] {
+  const n = ctx.numPositions;
+  const clauses: number[][] = [];
+  if (numVals) {
+    const validPairs: [number, number][] = [];
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        if (Math.abs(numVals[i] - numVals[j]) === distance) {
+          validPairs.push([i, j]);
+        }
       }
-      // Symmetric: if b at p, then a at p-1 or p+1
-      for (let p = 0; p < n; p++) {
-        const clause: number[] = [-variable(ctx, b, p)];
-        if (p > 0) clause.push(variable(ctx, a, p - 1));
-        if (p < n - 1) clause.push(variable(ctx, a, p + 1));
-        clauses.push(clause);
+    }
+    for (let p = 0; p < n; p++) {
+      const clause: number[] = [-variable(ctx, a, p)];
+      for (const [p1, p2] of validPairs) {
+        if (p1 === p) clause.push(variable(ctx, b, p2));
+        if (p2 === p) clause.push(variable(ctx, b, p1));
       }
-      return clauses;
+      clauses.push(clause);
     }
-
-    case "not_next_to": {
-      const { a, b } = constraint;
-      const clauses: number[][] = [];
-      for (let p = 0; p < n - 1; p++) {
-        clauses.push([-variable(ctx, a, p), -variable(ctx, b, p + 1)]);
-        clauses.push([-variable(ctx, a, p + 1), -variable(ctx, b, p)]);
+    for (let p = 0; p < n; p++) {
+      const clause: number[] = [-variable(ctx, b, p)];
+      for (const [p1, p2] of validPairs) {
+        if (p1 === p) clause.push(variable(ctx, a, p2));
+        if (p2 === p) clause.push(variable(ctx, a, p1));
       }
-      return clauses;
+      clauses.push(clause);
+    }
+  } else {
+    for (let p = 0; p < n; p++) {
+      const clause: number[] = [-variable(ctx, a, p)];
+      if (p + distance < n) clause.push(variable(ctx, b, p + distance));
+      if (p - distance >= 0) clause.push(variable(ctx, b, p - distance));
+      clauses.push(clause);
     }
+    for (let p = 0; p < n; p++) {
+      const clause: number[] = [-variable(ctx, b, p)];
+      if (p + distance < n) clause.push(variable(ctx, a, p + distance));
+      if (p - distance >= 0) clause.push(variable(ctx, a, p - distance));
+      clauses.push(clause);
+    }
+  }
+  return clauses;
+}
+
+/** Encode a single constraint as CNF clauses. */
+export function encodeConstraint(
+  ctx: EncodingContext,
+  constraint: Constraint,
+): number[][] {
+  const n = ctx.numPositions;
 
-    case "left_of": {
+  switch (constraint.type) {
+    case "same_position": {
       const { a, b } = constraint;
       const clauses: number[][] = [];
-      // a is immediately left of b: pos(a) = pos(b) - 1
-      for (let p = 0; p < n - 1; p++) {
-        clauses.push([-variable(ctx, a, p), variable(ctx, b, p + 1)]);
-      }
-      for (let p = 1; p < n; p++) {
-        clauses.push([-variable(ctx, b, p), variable(ctx, a, p - 1)]);
+      for (let p = 0; p < n; p++) {
+        clauses.push([-variable(ctx, a, p), variable(ctx, b, p)]);
+        clauses.push([-variable(ctx, b, p), variable(ctx, a, p)]);
       }
-      // a cannot be in last position
-      clauses.push([-variable(ctx, a, n - 1)]);
-      // b cannot be in first position
-      clauses.push([-variable(ctx, b, 0)]);
       return clauses;
     }
 
-    case "between": {
-      const { outer1, middle, outer2 } = constraint;
+    case "not_same_position": {
+      const { a, b } = constraint;
       const clauses: number[][] = [];
-      // For each pair of positions for outer1 and outer2,
-      // middle must be strictly between them
-      for (let po1 = 0; po1 < n; po1++) {
-        for (let po2 = 0; po2 < n; po2++) {
-          if (po1 === po2) {
-            // Can't both be at same position (handled by base, but be explicit)
-            continue;
-          }
-          const lo = Math.min(po1, po2);
-          const hi = Math.max(po1, po2);
-          const validMiddle: number[] = [];
-          for (let pm = lo + 1; pm < hi; pm++) {
-            validMiddle.push(variable(ctx, middle, pm));
-          }
-          // If outer1 at po1 and outer2 at po2, middle must be in valid range
-          if (validMiddle.length === 0) {
-            // Adjacent or same — this combination is forbidden
-            clauses.push([
-              -variable(ctx, outer1, po1),
-              -variable(ctx, outer2, po2),
-            ]);
-          } else {
-            clauses.push([
-              -variable(ctx, outer1, po1),
-              -variable(ctx, outer2, po2),
-              ...validMiddle,
-            ]);
-          }
-        }
+      for (let p = 0; p < n; p++) {
+        clauses.push([-variable(ctx, a, p), -variable(ctx, b, p)]);
       }
       return clauses;
     }
 
-    case "not_between": {
-      const { outer1, middle, outer2 } = constraint;
-      const clauses: number[][] = [];
-      // For each position of middle, forbid it from being strictly between
-      // outer1 and outer2. If middle at pm, then for all pairs (po1 < pm, po2 > pm)
-      // we forbid outer1 at po1 AND outer2 at po2 (and vice versa).
-      for (let pm = 1; pm < n - 1; pm++) {
-        for (let po1 = 0; po1 < pm; po1++) {
-          for (let po2 = pm + 1; po2 < n; po2++) {
-            clauses.push([
-              -variable(ctx, middle, pm),
-              -variable(ctx, outer1, po1),
-              -variable(ctx, outer2, po2),
-            ]);
-            clauses.push([
-              -variable(ctx, middle, pm),
-              -variable(ctx, outer1, po2),
-              -variable(ctx, outer2, po1),
-            ]);
-          }
+    case "next_to":
+    case "not_next_to":
+    case "left_of":
+    case "before": {
+      const axis = resolveAxis(ctx.grid, constraint.axis);
+      if (isIdentityPinnedAxis(ctx.grid, axis)) {
+        switch (constraint.type) {
+          case "next_to":
+            return encodePositionalNextTo(ctx, constraint.a, constraint.b);
+          case "not_next_to":
+            return encodePositionalNotNextTo(ctx, constraint.a, constraint.b);
+          case "left_of":
+            return encodePositionalLeftOf(ctx, constraint.a, constraint.b);
+          case "before":
+            return encodePositionalBefore(ctx, constraint.a, constraint.b);
         }
       }
-      return clauses;
+      const bad = badBinaryRankPairs(
+        constraint.type,
+        axis.values.length,
+        0,
+        undefined,
+      );
+      return encodeBinaryAxis(ctx, constraint.a, constraint.b, axis, bad);
     }
 
-    case "before": {
-      const { a, b } = constraint;
-      const clauses: number[][] = [];
-      // a is somewhere to the left of b: pos(a) < pos(b)
-      // If a at p, then b must be at some position > p
-      for (let p = 0; p < n; p++) {
-        const clause: number[] = [-variable(ctx, a, p)];
-        for (let q = p + 1; q < n; q++) {
-          clause.push(variable(ctx, b, q));
-        }
-        clauses.push(clause);
-      }
-      // Symmetric: if b at p, then a must be at some position < p
-      for (let p = 0; p < n; p++) {
-        const clause: number[] = [-variable(ctx, b, p)];
-        for (let q = 0; q < p; q++) {
-          clause.push(variable(ctx, a, q));
-        }
-        clauses.push(clause);
+    case "exact_distance": {
+      const axis = resolveAxis(ctx.grid, constraint.axis);
+      if (isIdentityPinnedAxis(ctx.grid, axis)) {
+        return encodePositionalExactDistance(
+          ctx,
+          constraint.a,
+          constraint.b,
+          constraint.distance,
+          axis.numericValues,
+        );
       }
-      return clauses;
+      const bad = badBinaryRankPairs(
+        "exact_distance",
+        axis.values.length,
+        constraint.distance,
+        axis.numericValues,
+      );
+      return encodeBinaryAxis(ctx, constraint.a, constraint.b, axis, bad);
     }
 
-    case "exact_distance": {
-      const { a, b, distance } = constraint;
-      const clauses: number[][] = [];
-      const numVals = findPositionCategory(ctx.grid)?.numericValues;
-
-      if (numVals) {
-        // Value-based distance: find position pairs where numeric values differ by distance
-        const validPairs: [number, number][] = [];
-        for (let i = 0; i < n; i++) {
-          for (let j = i + 1; j < n; j++) {
-            if (Math.abs(numVals[i] - numVals[j]) === distance) {
-              validPairs.push([i, j]);
-            }
-          }
-        }
-        // If a at p, b must be at one of the matching partner positions
-        for (let p = 0; p < n; p++) {
-          const clause: number[] = [-variable(ctx, a, p)];
-          for (const [p1, p2] of validPairs) {
-            if (p1 === p) clause.push(variable(ctx, b, p2));
-            if (p2 === p) clause.push(variable(ctx, b, p1));
-          }
-          clauses.push(clause);
-        }
-        // Symmetric
-        for (let p = 0; p < n; p++) {
-          const clause: number[] = [-variable(ctx, b, p)];
-          for (const [p1, p2] of validPairs) {
-            if (p1 === p) clause.push(variable(ctx, a, p2));
-            if (p2 === p) clause.push(variable(ctx, a, p1));
-          }
-          clauses.push(clause);
-        }
-      } else {
-        // Position-based distance (original behavior)
-        for (let p = 0; p < n; p++) {
-          const clause: number[] = [-variable(ctx, a, p)];
-          if (p + distance < n) clause.push(variable(ctx, b, p + distance));
-          if (p - distance >= 0) clause.push(variable(ctx, b, p - distance));
-          clauses.push(clause);
-        }
-        for (let p = 0; p < n; p++) {
-          const clause: number[] = [-variable(ctx, b, p)];
-          if (p + distance < n) clause.push(variable(ctx, a, p + distance));
-          if (p - distance >= 0) clause.push(variable(ctx, a, p - distance));
-          clauses.push(clause);
-        }
+    case "between":
+    case "not_between": {
+      const axis = resolveAxis(ctx.grid, constraint.axis);
+      if (isIdentityPinnedAxis(ctx.grid, axis)) {
+        return constraint.type === "between"
+          ? encodePositionalBetween(
+              ctx,
+              constraint.outer1,
+              constraint.middle,
+              constraint.outer2,
+            )
+          : encodePositionalNotBetween(
+              ctx,
+              constraint.outer1,
+              constraint.middle,
+              constraint.outer2,
+            );
       }
-      return clauses;
+      return encodeBetweenAxis(
+        ctx,
+        constraint.outer1,
+        constraint.middle,
+        constraint.outer2,
+        axis,
+        constraint.type === "not_between",
+      );
     }
 
     case "at_position": {
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index bc716c1..f997780 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -2,10 +2,13 @@ import { describe, it, expect } from "vitest";
 import { generate } from "./generator";
 import { deduce } from "./deduce";
 import { hasUniqueSolution, solve } from "./solver";
+import { resolveAxis } from "./axis";
+import { TEST_COMPARATORS } from "./test-helpers";
+import type { Category, Grid } from "./types";
 
 describe("generate", () => {
   it("returns a valid puzzle with defaults", () => {
-    const puzzle = generate();
+    const puzzle = generate({ seed: 1 });
 
     expect(puzzle.grid.size).toBe(4);
     expect(puzzle.grid.categories.length).toBe(4);
@@ -16,7 +19,7 @@ describe("generate", () => {
   });
 
   it("solution is a valid permutation", () => {
-    const puzzle = generate();
+    const puzzle = generate({ seed: 2 });
 
     for (const assignment of puzzle.solution) {
       const positions = Object.values(assignment);
@@ -30,7 +33,7 @@ describe("generate", () => {
   });
 
   it("constraints are consistent with the solution", () => {
-    const puzzle = generate();
+    const puzzle = generate({ seed: 3 });
     const posOf = new Map<string, number>();
     for (const assignment of puzzle.solution) {
       for (const [val, pos] of Object.entries(assignment)) {
@@ -38,6 +41,16 @@ describe("generate", () => {
       }
     }
 
+    // rank(value, axis) = index of the axis value colocated with `value`.
+    const rankOf = (val: string, grid: Grid, axisName: string): number => {
+      const axis = resolveAxis(grid, axisName);
+      const pos = posOf.get(val)!;
+      for (let k = 0; k < axis.values.length; k++) {
+        if (posOf.get(axis.values[k]) === pos) return k;
+      }
+      throw new Error(`No ${axisName} value colocated with ${val}`);
+    };
+
     for (const c of puzzle.constraints) {
       switch (c.type) {
         case "same_position":
@@ -46,20 +59,32 @@ describe("generate", () => {
         case "not_same_position":
           expect(posOf.get(c.a)).not.toBe(posOf.get(c.b));
           break;
-        case "next_to":
-          expect(Math.abs(posOf.get(c.a)! - posOf.get(c.b)!)).toBe(1);
+        case "next_to": {
+          const ra = rankOf(c.a, puzzle.grid, c.axis);
+          const rb = rankOf(c.b, puzzle.grid, c.axis);
+          expect(Math.abs(ra - rb)).toBe(1);
           break;
-        case "not_next_to":
-          expect(Math.abs(posOf.get(c.a)! - posOf.get(c.b)!)).not.toBe(1);
+        }
+        case "not_next_to": {
+          const ra = rankOf(c.a, puzzle.grid, c.axis);
+          const rb = rankOf(c.b, puzzle.grid, c.axis);
+          expect(Math.abs(ra - rb)).not.toBe(1);
           break;
-        case "left_of":
-          expect(posOf.get(c.b)! - posOf.get(c.a)!).toBe(1);
+        }
+        case "left_of": {
+          const ra = rankOf(c.a, puzzle.grid, c.axis);
+          const rb = rankOf(c.b, puzzle.grid, c.axis);
+          expect(rb - ra).toBe(1);
           break;
+        }
         case "between": {
-          const lo = Math.min(posOf.get(c.outer1)!, posOf.get(c.outer2)!);
-          const hi = Math.max(posOf.get(c.outer1)!, posOf.get(c.outer2)!);
-          expect(posOf.get(c.middle)!).toBeGreaterThan(lo);
-          expect(posOf.get(c.middle)!).toBeLessThan(hi);
+          const r1 = rankOf(c.outer1, puzzle.grid, c.axis);
+          const r2 = rankOf(c.outer2, puzzle.grid, c.axis);
+          const rm = rankOf(c.middle, puzzle.grid, c.axis);
+          const lo = Math.min(r1, r2);
+          const hi = Math.max(r1, r2);
+          expect(rm).toBeGreaterThan(lo);
+          expect(rm).toBeLessThan(hi);
           break;
         }
         case "at_position":
@@ -68,25 +93,40 @@ describe("generate", () => {
         case "not_at_position":
           expect(posOf.get(c.value)).not.toBe(c.position);
           break;
-        case "before":
-          expect(posOf.get(c.a)!).toBeLessThan(posOf.get(c.b)!);
+        case "before": {
+          const ra = rankOf(c.a, puzzle.grid, c.axis);
+          const rb = rankOf(c.b, puzzle.grid, c.axis);
+          expect(ra).toBeLessThan(rb);
           break;
+        }
         case "not_between": {
-          const lo = Math.min(posOf.get(c.outer1)!, posOf.get(c.outer2)!);
-          const hi = Math.max(posOf.get(c.outer1)!, posOf.get(c.outer2)!);
-          const mid = posOf.get(c.middle)!;
-          expect(mid > lo && mid < hi).toBe(false);
+          const r1 = rankOf(c.outer1, puzzle.grid, c.axis);
+          const r2 = rankOf(c.outer2, puzzle.grid, c.axis);
+          const rm = rankOf(c.middle, puzzle.grid, c.axis);
+          const lo = Math.min(r1, r2);
+          const hi = Math.max(r1, r2);
+          expect(rm > lo && rm < hi).toBe(false);
           break;
         }
-        case "exact_distance":
-          expect(Math.abs(posOf.get(c.a)! - posOf.get(c.b)!)).toBe(c.distance);
+        case "exact_distance": {
+          const axis = resolveAxis(puzzle.grid, c.axis);
+          const ra = rankOf(c.a, puzzle.grid, c.axis);
+          const rb = rankOf(c.b, puzzle.grid, c.axis);
+          if (axis.numericValues) {
+            expect(
+              Math.abs(axis.numericValues[ra] - axis.numericValues[rb]),
+            ).toBe(c.distance);
+          } else {
+            expect(Math.abs(ra - rb)).toBe(c.distance);
+          }
           break;
+        }
       }
     }
   });
 
   it("puzzle has a unique solution", () => {
-    const puzzle = generate();
+    const puzzle = generate({ seed: 4 });
     expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
   });
 
@@ -146,44 +186,6 @@ describe("generate", () => {
     expect(() => generate({ categories: 9 })).toThrow(RangeError);
   });
 
-  it("accepts valid positionNoun", () => {
-    const puzzle = generate({
-      size: 3,
-      seed: 1,
-      positionNoun: ["seat", "seats"],
-    });
-    expect(puzzle.grid.positionNoun).toEqual(["seat", "seats"]);
-  });
-
-  it("rejects empty positionNoun strings", () => {
-    expect(() => generate({ size: 3, positionNoun: ["", "slots"] })).toThrow(
-      RangeError,
-    );
-    expect(() => generate({ size: 3, positionNoun: ["slot", ""] })).toThrow(
-      RangeError,
-    );
-  });
-
-  it("custom positionPreposition derives atPosition without a position category", () => {
-    const puzzle = generate({
-      size: 3,
-      categories: 3,
-      seed: 1,
-      positionNoun: ["seat", "seats"],
-      positionPreposition: "at",
-    });
-    expect(puzzle.grid.spatialWords.atPosition).toEqual([
-      "lives at",
-      "does not live at",
-    ]);
-  });
-
-  it("rejects empty positionPreposition", () => {
-    expect(() => generate({ size: 3, positionPreposition: "" })).toThrow(
-      RangeError,
-    );
-  });
-
   it("accepts custom categories", () => {
     const puzzle = generate({
       size: 3,
@@ -193,6 +195,8 @@ describe("generate", () => {
           values: ["A", "B", "C"],
           noun: "house",
           verb: ["lives in", "does not live in"],
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
         {
           name: "Owner",
@@ -346,124 +350,107 @@ describe("generate", () => {
     ).toThrow('Category "Color" has 2 values but size is 5');
   });
 
-  it("throws when non-person category lacks verb", () => {
+  it("throws on duplicate category names", () => {
     expect(() =>
       generate({
         size: 3,
         categoryNames: [
           { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
           {
-            name: "Color",
-            values: ["Red", "Blue", "Green"],
-            noun: "house",
-            // missing verb
+            name: "Dupe",
+            values: ["A", "B", "C"],
+            noun: "x",
+            verb: ["is", "is not"],
           },
           {
-            name: "Pet",
-            values: ["Cat", "Dog", "Fish"],
-            noun: "owner",
-            verb: ["owns the", "does not own the"],
+            name: "Dupe",
+            values: ["D", "E", "F"],
+            noun: "y",
+            verb: ["has", "has not"],
           },
         ],
       }),
-    ).toThrow("requires a verb");
+    ).toThrow("Duplicate category name");
   });
 
-  it("throws when position category lacks verb", () => {
+  it("throws when numericValues length does not match values", () => {
     expect(() =>
       generate({
         size: 3,
         categoryNames: [
           { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
           {
-            name: "Time",
-            values: ["7am", "8am", "9am"],
-            noun: "", // person noun bypasses non-person check, but isPosition check should fire
-            isPosition: true,
+            name: "Year",
+            values: ["2020", "2021", "2022"],
+            noun: "year",
+            verb: ["started in", "did not start in"],
+            ordered: true,
+            numericValues: [2020, 2021],
+            orderingPhrases: { comparators: TEST_COMPARATORS },
           },
           {
             name: "Color",
             values: ["Red", "Blue", "Green"],
-            noun: "house",
-            verb: ["lives in the", "does not live in the"],
+            noun: "color",
+            verb: ["wears", "does not wear"],
           },
         ],
       }),
-    ).toThrow("Position category");
+    ).toThrow("numericValues length must match values length");
   });
 
-  it("throws when more than one category is isPosition", () => {
+  it("throws when displayAxis references a non-ordered category", () => {
     expect(() =>
       generate({
         size: 3,
         categoryNames: [
           { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-          {
-            name: "Time",
-            values: ["7am", "8am", "9am"],
-            noun: "slot",
-            verb: ["is at", "is not at"],
-            isPosition: true,
-          },
           {
             name: "Year",
             values: ["2020", "2021", "2022"],
             noun: "year",
-            verb: ["was in", "was not in"],
-            isPosition: true,
+            verb: ["started in", "did not start in"],
+            ordered: true,
+            orderingPhrases: { comparators: TEST_COMPARATORS },
+          },
+          {
+            name: "Color",
+            values: ["Red", "Blue", "Green"],
+            noun: "color",
+            verb: ["wears", "does not wear"],
           },
         ],
+        displayAxis: "Color",
       }),
-    ).toThrow("At most one category can have isPosition");
+    ).toThrow("must reference an ordered category");
   });
 
-  it("throws when symmetric comparator is a tuple", () => {
+  it("throws when non-person category lacks verb", () => {
     expect(() =>
       generate({
         size: 3,
         categoryNames: [
           { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
           {
-            name: "Time",
-            values: ["7am", "8am", "9am"],
-            noun: "slot",
-            verb: ["is at", "is not at"],
-            isPosition: true,
-            orderingPhrases: {
-              comparators: {
-                next_to: ["fwd", "rev"],
-              },
-            },
+            name: "Color",
+            values: ["Red", "Blue", "Green"],
+            noun: "house",
+            // missing verb
           },
           {
-            name: "Activity",
-            values: ["Yoga", "Cardio", "Run"],
-            noun: "doer",
-            verb: ["does", "does not do"],
+            name: "Pet",
+            values: ["Cat", "Dog", "Fish"],
+            noun: "owner",
+            verb: ["owns the", "does not own the"],
           },
         ],
       }),
-    ).toThrow('comparator "next_to" is symmetric');
+    ).toThrow("requires a verb");
   });
 
-  it("throws when category has both isPosition and positionAdjective", () => {
-    expect(() =>
-      generate({
-        size: 3,
-        categoryNames: [
-          { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-          {
-            name: "Time",
-            values: ["7am", "8am", "9am"],
-            isPosition: true,
-            valueSuffix: "slot",
-            positionAdjective: ["is", "is not"],
-          },
-          { name: "Color", values: ["Red", "Blue", "Green"] },
-        ],
-      }),
-    ).toThrow("cannot be both isPosition and positionAdjective");
-  });
+  // "symmetric comparator as tuple" is now a compile-time error:
+  // ComparatorMap requires next_to/not_next_to/between/not_between/exact_distance
+  // to be plain strings, not [forward, reverse] tuples.
 
   it("throws when numericValues are not in ascending order", () => {
     expect(() =>
@@ -474,7 +461,10 @@ describe("generate", () => {
           {
             name: "Time",
             values: ["7am", "8am", "9am"],
-            isPosition: true,
+            noun: "slot",
+            verb: ["is at", "is not at"],
+            ordered: true,
+            orderingPhrases: { comparators: TEST_COMPARATORS },
             numericValues: [9, 7, 8],
           },
           { name: "Color", values: ["Red", "Blue", "Green"] },
@@ -494,9 +484,12 @@ describe("generate", () => {
           values: ["3%", "5%", "8%", "12%"],
           noun: "fund",
           verb: ["has a return of", "does not have a return of"],
-          isPosition: true,
+          ordered: true,
           numericValues: [3, 5, 8, 12],
-          orderingPhrases: { unit: ["percentage point", "percentage points"] },
+          orderingPhrases: {
+            unit: ["percentage point", "percentage points"] as [string, string],
+            comparators: TEST_COMPARATORS,
+          },
         },
         {
           name: "Strategy",
@@ -509,7 +502,8 @@ describe("generate", () => {
 
     expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
 
-    // Verify all exact_distance constraints use value-based distances (not positional)
+    // exact_distance constraints are emitted for value pairs whose
+    // numeric gap matches. The emitted distance should be in the valid set.
     const validValueDistances = new Set<number>();
     const numVals = [3, 5, 8, 12];
     for (let i = 0; i < numVals.length; i++) {
@@ -524,7 +518,7 @@ describe("generate", () => {
     }
   });
 
-  it("position category gets identity assignment", () => {
+  it("first ordered category gets identity assignment", () => {
     const puzzle = generate({
       size: 4,
       seed: 42,
@@ -535,11 +529,11 @@ describe("generate", () => {
           values: ["6%", "7%", "8%", "9%"],
           noun: "fund",
           verb: ["has a return of", "does not have a return of"],
-          isPosition: true,
+          ordered: true,
           numericValues: [6, 7, 8, 9],
           orderingPhrases: {
-            unit: ["percentage point", "percentage points"],
-            comparators: { before: "has a lower return than" },
+            unit: ["percentage point", "percentage points"] as [string, string],
+            comparators: TEST_COMPARATORS,
           },
         },
         {
@@ -551,7 +545,7 @@ describe("generate", () => {
       ],
     });
 
-    // Position category should have identity mapping
+    // First ordered category (Return) gets identity mapping.
     const returnAssignment = puzzle.solution.find((a) => "6%" in a)!;
     expect(returnAssignment["6%"]).toBe(0);
     expect(returnAssignment["7%"]).toBe(1);
@@ -561,7 +555,7 @@ describe("generate", () => {
     expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
   });
 
-  it("position category is preserved in grid", () => {
+  it("ordered category is preserved in grid", () => {
     const puzzle = generate({
       size: 3,
       seed: 1,
@@ -572,7 +566,8 @@ describe("generate", () => {
           values: ["9am", "10am", "11am"],
           noun: "slot",
           verb: ["is at", "is not at"],
-          isPosition: true,
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
         {
           name: "Color",
@@ -583,9 +578,123 @@ describe("generate", () => {
       ],
     });
 
-    const posCat = puzzle.grid.categories.find((c) => c.isPosition);
-    expect(posCat).toBeDefined();
-    expect(posCat!.name).toBe("Time");
-    expect(posCat!.isPosition).toBe(true);
+    const orderedCat = puzzle.grid.categories.find((c) => c.ordered === true);
+    expect(orderedCat).toBeDefined();
+    expect(orderedCat!.name).toBe("Time");
+  });
+});
+
+describe("generate with multiple ordered categories", () => {
+  const hedgeFundCategories: Category[] = [
+    {
+      name: "Manager",
+      values: ["Alice", "Bob", "Carol", "Dan"],
+      noun: "",
+      subjectPriority: 2,
+    },
+    {
+      name: "Year",
+      values: ["1972", "1983", "1997", "2005"],
+      noun: "fund",
+      verb: ["was begun in", "was not begun in"] as [string, string],
+      subjectPriority: -1,
+      ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
+    },
+    {
+      name: "Return",
+      values: ["6%", "7%", "8%", "9%"],
+      noun: "fund",
+      verb: ["has a return of", "does not have a return of"] as [
+        string,
+        string,
+      ],
+      subjectPriority: -1,
+      ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
+    },
+    {
+      name: "Strategy",
+      values: ["Long/Short", "Macro", "Quant", "Event"],
+      noun: "strategist",
+      subjectPriority: 1,
+      verb: ["uses the", "does not use the"] as [string, string],
+      valueSuffix: "strategy",
+    },
+  ];
+
+  it("generates a puzzle with two ordered axes and solves uniquely", () => {
+    const puzzle = generate({
+      size: 4,
+      seed: 42,
+      categoryNames: hedgeFundCategories,
+    });
+
+    expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
+    const solved = solve(puzzle.constraints, puzzle.grid);
+    expect(solved).not.toBeNull();
+  });
+
+  it("emits at least some constraints tagged with each ordered axis", () => {
+    // Seeded sweep so that eventually both axes appear in some puzzle's
+    // minimal set. The axis choice in the final puzzle is probabilistic —
+    // minimization may drop constraints on one axis if the other is
+    // sufficient. We only assert that the generator is CAPABLE of emitting
+    // constraints on both axes.
+    let sawYear = false;
+    let sawReturn = false;
+    for (let seed = 0; seed < 20 && !(sawYear && sawReturn); seed++) {
+      const puzzle = generate({
+        size: 4,
+        seed,
+        categoryNames: hedgeFundCategories,
+      });
+      for (const c of puzzle.constraints) {
+        if ("axis" in c) {
+          if (c.axis === "Year") sawYear = true;
+          if (c.axis === "Return") sawReturn = true;
+        }
+      }
+    }
+    expect(sawYear).toBe(true);
+    expect(sawReturn).toBe(true);
+  });
+
+  it("multi-axis puzzles still round-trip through the SAT solver", () => {
+    // The SAT solver must reproduce the exact solution. Deduction may stall
+    // on constraints targeting a non-pinned axis (rank-space propagation is
+    // weaker than positional), but the solver handles it.
+    const puzzle = generate({
+      size: 4,
+      seed: 7,
+      categoryNames: hedgeFundCategories,
+    });
+    const solved = solve(puzzle.constraints, puzzle.grid);
+    expect(solved).not.toBeNull();
+    for (let ci = 0; ci < puzzle.solution.length; ci++) {
+      for (const [val, pos] of Object.entries(puzzle.solution[ci])) {
+        expect(solved![ci][val]).toBe(pos);
+      }
+    }
+  });
+
+  it("generates a size-4 multi-axis puzzle exercising both encoder paths", () => {
+    // Exercises both the identity-pinned fast path (Year, first ordered)
+    // and the rank-forbidding path (Return, second ordered) in one puzzle.
+    const puzzle = generate({
+      size: 4,
+      seed: 99,
+      categoryNames: hedgeFundCategories,
+    });
+    expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
+
+    // Verify constraints reference both axes.
+    const axes = new Set<string>();
+    for (const c of puzzle.constraints) {
+      if ("axis" in c && typeof c.axis === "string") axes.add(c.axis);
+    }
+    // At minimum the first ordered axis should appear; second may be
+    // dropped by minimization for some seeds.
+    expect(axes.size).toBeGreaterThanOrEqual(1);
   });
 });
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index e315eaa..a9b932e 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -2,7 +2,6 @@ import type {
   Puzzle,
   GenerateOptions,
   Grid,
-  ComparatorMap,
   Solution,
   Constraint,
   Category,
@@ -16,71 +15,45 @@ import { IncrementalSolver } from "./sat";
 import { renderClue } from "./clues/templates";
 import { classify, EASY_TYPES, MEDIUM_TYPES } from "./difficulty";
 import { deduce } from "./deduce";
-import { ORDINALS } from "./grid-utils";
-import { DEFAULT_CONFIG } from "./default-config";
+import { isOrdered, orderedCategories, resolveAxis } from "./axis";
+import { DEFAULT_CATEGORIES, defaultHouseCategory } from "./default-config";
 
 const MAX_RETRIES = 100;
 
-// Symmetric constraint types — comparators must be a single string, not a tuple.
-// NOTE: duplicated in logic-grid-ai/src/validation.ts so the AI retry loop can
-// catch this without depending on the core package. Keep both lists in sync.
-const SYMMETRIC_COMPARATORS = new Set([
-  "next_to",
-  "not_next_to",
-  "between",
-  "not_between",
-  "exact_distance",
-]);
-
-function checkComparators(
-  scope: string,
-  comparators: ComparatorMap | undefined,
-): void {
-  if (!comparators) return;
-  for (const [type, value] of Object.entries(comparators)) {
-    if (Array.isArray(value) && SYMMETRIC_COMPARATORS.has(type)) {
-      throw new RangeError(
-        `${scope} comparator "${type}" is symmetric and must be a single string, not [forward, reverse]`,
-      );
-    }
-  }
-}
-
 /**
- * Validate per-category invariants. Called by buildGrid before constructing
- * dependent fields (e.g. spatialWords.atPosition from posCat.verb), so
- * downstream code can rely on these invariants.
+ * Validate per-category invariants. Called by buildGrid before the grid is
+ * used for anything, so downstream code can rely on these invariants.
  */
 function validateCategories(categories: Category[]): void {
-  let positionCount = 0;
+  const names = new Set<string>();
   for (const c of categories) {
-    if (c.isPosition) positionCount++;
-    if (c.numericValues) {
-      for (let i = 1; i < c.numericValues.length; i++) {
-        if (c.numericValues[i] <= c.numericValues[i - 1]) {
-          throw new RangeError(
-            `Category "${c.name}" numericValues must be in ascending order`,
-          );
-        }
-      }
-    }
-    if (c.isPosition && c.positionAdjective) {
-      throw new RangeError(
-        `Category "${c.name}" cannot be both isPosition and positionAdjective`,
-      );
+    if (names.has(c.name)) {
+      throw new RangeError(`Duplicate category name "${c.name}"`);
     }
+    names.add(c.name);
+
     if (c.noun !== "" && !c.verb) {
       throw new RangeError(
         `Category "${c.name}" requires a verb (only the person category may omit it)`,
       );
     }
-    if (c.isPosition && !c.verb) {
-      throw new RangeError(`Position category "${c.name}" requires a verb`);
+
+    if (isOrdered(c)) {
+      if (c.numericValues !== undefined) {
+        if (c.numericValues.length !== c.values.length) {
+          throw new RangeError(
+            `Category "${c.name}" numericValues length must match values length`,
+          );
+        }
+        for (let i = 1; i < c.numericValues.length; i++) {
+          if (c.numericValues[i] <= c.numericValues[i - 1]) {
+            throw new RangeError(
+              `Category "${c.name}" numericValues must be in ascending order`,
+            );
+          }
+        }
+      }
     }
-    checkComparators(`Category "${c.name}"`, c.orderingPhrases?.comparators);
-  }
-  if (positionCount > 1) {
-    throw new RangeError("At most one category can have isPosition: true");
   }
 }
 
@@ -124,6 +97,12 @@ export function generate(options?: GenerateOptions): Puzzle {
       grid,
       difficulty !== "expert",
     );
+    // minimizeConstraints returns [] when the constructive phase can't achieve
+    // uniqueness. Unreachable for supported grid sizes with seeded RNG but
+    // observed with Math.random on some platforms (CI flake).
+    /* v8 ignore next */
+    if (minimal.length === 0) continue;
+
     const actualDifficulty = classify(minimal, grid);
 
     // If specific difficulty requested and doesn't match, retry
@@ -152,18 +131,6 @@ function buildGrid(
   options?: GenerateOptions,
 ): Grid {
   const categoryNames = options?.categoryNames;
-  if (options?.positionNoun !== undefined) {
-    const [singular, plural] = options.positionNoun;
-    if (!singular || !plural)
-      throw new RangeError(
-        "positionNoun singular and plural must be non-empty",
-      );
-  }
-  if (
-    options?.positionPreposition !== undefined &&
-    !options.positionPreposition
-  )
-    throw new RangeError("positionPreposition must be non-empty");
   let categories: Category[];
 
   if (categoryNames) {
@@ -177,77 +144,74 @@ function buildGrid(
         );
       }
     }
-    categories = categoryNames.map((c) => {
-      const noun = c.noun ?? "";
-      // Default subjectPriority: 2 for person, 0 for everything else.
-      const subjectPriority = c.subjectPriority ?? (noun === "" ? 2 : 0);
-      return {
-        name: c.name,
-        values: c.values.slice(0, size),
-        noun,
-        verb: c.verb,
-        subjectPriority,
-        valueSuffix: c.valueSuffix,
-        positionAdjective: c.positionAdjective,
-        isPosition: c.isPosition,
-        numericValues: c.numericValues?.slice(0, size),
-        orderingPhrases: c.orderingPhrases,
-      };
-    });
+    categories = categoryNames.map((c) => sliceCategory(c, size));
+    // Ensure at least one ordered category; auto-prepend House if the user's
+    // categories include none.
+    if (!categories.some((c) => c.ordered === true)) {
+      categories = [defaultHouseCategory(size), ...categories];
+    }
   } else {
-    categories = DEFAULT_CONFIG.categories.slice(0, numCategories).map((c) => ({
-      ...c,
-      values: c.values.slice(0, size),
-    }));
+    // Default pool has no ordered category; House is always prepended as the
+    // first ordered slot. Total category count is preserved.
+    categories = [
+      defaultHouseCategory(size),
+      ...DEFAULT_CATEGORIES.slice(0, numCategories - 1).map((c) =>
+        sliceCategory(c, size),
+      ),
+    ];
   }
 
-  const posNoun = options?.positionNoun ?? DEFAULT_CONFIG.positionNoun;
-  const posPrep =
-    options?.positionPreposition ?? DEFAULT_CONFIG.positionPreposition;
-  const posCat = categories.find((c) => c.isPosition);
-
-  // Validate per-category invariants before constructing dependent fields.
   validateCategories(categories);
 
   const grid: Grid = {
     size,
     categories,
-    positionNoun: posNoun,
-    positionPreposition: posPrep,
-    spatialWords: posCat
-      ? {
-          ...DEFAULT_CONFIG.spatialWords,
-          verb: ["is", "is not"],
-          adjacency: "adjacent to",
-          direction: ["before", "after"],
-          atPosition: posCat.verb as [string, string],
-          comparators: posCat.orderingPhrases?.comparators,
-          distanceUnit: posCat.orderingPhrases?.unit,
-        }
-      : {
-          ...DEFAULT_CONFIG.spatialWords,
-          // Derive atPosition from positionPreposition so custom prepositions
-          // ("at" → "lives at") work without a position category.
-          atPosition: [
-            `${DEFAULT_CONFIG.spatialWords.verb[0]} ${posPrep}`,
-            `${DEFAULT_CONFIG.spatialWords.verb[1]} ${posPrep}`,
-          ],
-        },
-    positionLabels: posCat
-      ? posCat.values.slice()
-      : Array.from(
-          { length: size },
-          (_, i) => `the ${ORDINALS[i]} ${posNoun[0]}`,
-        ),
+    displayAxis: options?.displayAxis,
   };
-  checkComparators("Grid spatialWords", grid.spatialWords.comparators);
+
+  // Validate displayAxis references an ordered category if set.
+  if (grid.displayAxis !== undefined) {
+    resolveAxis(grid, grid.displayAxis);
+  }
   return grid;
 }
 
+/** Copy a user-provided category, slicing values/numericValues to grid size. */
+function sliceCategory(c: Category, size: number): Category {
+  const noun = c.noun ?? "";
+  const subjectPriority = c.subjectPriority ?? (noun === "" ? 2 : 0);
+  const base = {
+    name: c.name,
+    values: c.values.slice(0, size),
+    noun,
+    verb: c.verb,
+    subjectPriority,
+  };
+  // Spread optional valueSuffix/positionAdjective respecting the discriminated union.
+  const withSuffix =
+    c.valueSuffix !== undefined
+      ? { valueSuffix: c.valueSuffix, positionAdjective: c.positionAdjective }
+      : {};
+  if (isOrdered(c)) {
+    return {
+      ...base,
+      ordered: true,
+      numericValues: c.numericValues?.slice(0, size),
+      orderingPhrases: c.orderingPhrases,
+      displayLabels: c.displayLabels?.slice(0, size),
+      ...withSuffix,
+    } as Category; // spread loses union discrimination
+  }
+  return { ...base, ...withSuffix } as Category;
+}
+
 function randomSolution(grid: Grid, rng: () => number): Solution {
-  return grid.categories.map((cat) => {
-    if (cat.isPosition) {
-      // Identity mapping: value[i] → position i
+  // Identity-assign the first ordered category so row = axis rank for it.
+  // This lets the positional fast-path encoder handle constraints on this axis
+  // cheaply. Other ordered axes use the rank-forbidding encoder.
+  const firstOrdered = grid.categories.findIndex((c) => c.ordered === true);
+  return grid.categories.map((cat, idx) => {
+    if (idx === firstOrdered) {
       const assignment: Assignment = {};
       for (let i = 0; i < cat.values.length; i++) {
         assignment[cat.values[i]] = i;
@@ -268,8 +232,7 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
   const constraints: Constraint[] = [];
   const n = grid.size;
 
-  // Find position category index (if any)
-  const posCatIndex = grid.categories.findIndex((c) => c.isPosition);
+  const orderedCats = orderedCategories(grid);
 
   // Build indexed arrays for fast access (avoid Map lookups in hot loops)
   const allValues: string[] = [];
@@ -282,137 +245,178 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
       catArr.push(ci);
     }
   }
-  // Also keep a Map for position constraints below
+  // Map from value name → its row position. Used for the at_position block.
   const posOf = new Map<string, number>();
   for (let i = 0; i < allValues.length; i++) posOf.set(allValues[i], posArr[i]);
 
-  // Cap negative pairwise types independently — a shared counter would starve not_next_to.
+  // --- Axis-free constraints (same_position, not_same_position) ---
+  // Cap negative pairwise types independently — a shared counter would
+  // starve not_next_to (which is enumerated per-axis below).
   const maxPerType = n * n;
   let notSameCount = 0;
-  let notNextCount = 0;
-
-  const numVals =
-    posCatIndex >= 0 ? grid.categories[posCatIndex].numericValues : undefined;
 
   for (let i = 0; i < allValues.length; i++) {
     const a = allValues[i];
     const posA = posArr[i];
     const catA = catArr[i];
-
     for (let j = i + 1; j < allValues.length; j++) {
       if (catArr[j] === catA) continue;
       const b = allValues[j];
       const posB = posArr[j];
-
       if (posA === posB) {
         constraints.push({ type: "same_position", a, b });
       } else if (notSameCount < maxPerType) {
         constraints.push({ type: "not_same_position", a, b });
         notSameCount++;
       }
+    }
+  }
 
-      if (Math.abs(posA - posB) === 1) {
-        constraints.push({ type: "next_to", a, b });
-      } else if (posA !== posB && notNextCount < maxPerType) {
-        constraints.push({ type: "not_next_to", a, b });
-        notNextCount++;
-      }
-
-      if (posA === posB - 1) {
-        constraints.push({ type: "left_of", a, b });
-      }
-      if (posB === posA - 1) {
-        constraints.push({ type: "left_of", a: b, b: a });
-      }
-
-      // before: a is somewhere left of b (not necessarily adjacent)
-      if (posA < posB) {
-        constraints.push({ type: "before", a, b });
-      } else if (posB < posA) {
-        constraints.push({ type: "before", a: b, b: a });
-      }
+  // --- Per-axis comparative constraints ---
+  // For each ordered category, compute each value's rank on that axis and
+  // emit constraints whose semantics match. Values belonging to the axis
+  // category itself are skipped — their rank is trivially their own index.
+  for (const axis of orderedCats) {
+    const axisName = axis.name;
+    const axisCatIdx = grid.categories.indexOf(axis);
+    // Rank lookup: for each row r in [0..n), which axis value index sits there?
+    // (i.e. rankAtRow[r] = k means axis.values[k] is assigned to row r.)
+    const rankAtRow = new Array<number>(n);
+    for (let k = 0; k < axis.values.length; k++) {
+      rankAtRow[solution[axisCatIdx][axis.values[k]]] = k;
+    }
+    const numVals = axis.numericValues;
+
+    let nextCount = 0;
+    let notNextCount = 0;
+    for (let i = 0; i < allValues.length; i++) {
+      if (catArr[i] === axisCatIdx) continue;
+      const a = allValues[i];
+      const rankA = rankAtRow[posArr[i]];
+      const catA = catArr[i];
+      for (let j = i + 1; j < allValues.length; j++) {
+        if (catArr[j] === catA) continue;
+        if (catArr[j] === axisCatIdx) continue;
+        const b = allValues[j];
+        const rankB = rankAtRow[posArr[j]];
+
+        if (Math.abs(rankA - rankB) === 1 && nextCount < maxPerType) {
+          constraints.push({ type: "next_to", a, b, axis: axisName });
+          nextCount++;
+        } else if (rankA !== rankB && notNextCount < maxPerType) {
+          constraints.push({ type: "not_next_to", a, b, axis: axisName });
+          notNextCount++;
+        }
 
-      // exact_distance: emit when meaningful (not redundant with other clue types).
-      if (numVals) {
-        // Value-based distance: emit any non-zero value gap. Even when positions
-        // are adjacent, the constraint is more specific than next_to (it pins
-        // the exact value pair, not just adjacency).
-        const valDist = Math.abs(numVals[posA] - numVals[posB]);
-        if (valDist > 0) {
-          constraints.push({ type: "exact_distance", a, b, distance: valDist });
+        if (rankA === rankB - 1) {
+          constraints.push({ type: "left_of", a, b, axis: axisName });
         }
-      } else {
-        // Position-based: distance 1 is exactly equivalent to next_to, skip it.
-        const dist = Math.abs(posA - posB);
-        if (dist >= 2) {
-          constraints.push({ type: "exact_distance", a, b, distance: dist });
+        if (rankB === rankA - 1) {
+          constraints.push({ type: "left_of", a: b, b: a, axis: axisName });
         }
-      }
-    }
-  }
 
-  // Between constraints (triples from different categories)
-  // Cap loop iterations — O(n³) without bound
-  const maxBetween = n * n;
-  let betweenCount = 0;
-  outer: for (
-    let i = 0;
-    i < allValues.length && betweenCount < maxBetween;
-    i++
-  ) {
-    const ai = allValues[i],
-      catAi = catArr[i],
-      posAi = posArr[i];
-    for (
-      let j = i + 1;
-      j < allValues.length && betweenCount < maxBetween;
-      j++
-    ) {
-      const catAj = catArr[j];
-      if (catAj === catAi) continue;
-      const aj = allValues[j],
-        posAj = posArr[j];
-      for (let k = j + 1; k < allValues.length; k++) {
-        const catAk = catArr[k];
-        if (catAk === catAi || catAk === catAj) continue;
-        const ak = allValues[k],
-          posAk = posArr[k];
-        // Check each of the 3 values as potential middle
-        const vals = [ai, aj, ak];
-        const positions = [posAi, posAj, posAk];
-        for (let m = 0; m < 3; m++) {
-          const o0 = m === 0 ? 1 : 0;
-          const o1 = m === 2 ? 1 : 2;
-          const lo = Math.min(positions[o0], positions[o1]);
-          const hi = Math.max(positions[o0], positions[o1]);
-          const [v1, v2] =
-            vals[o0] < vals[o1] ? [vals[o0], vals[o1]] : [vals[o1], vals[o0]];
-          if (positions[m] > lo && positions[m] < hi) {
+        // before: a's rank is strictly less than b's rank
+        if (rankA < rankB) {
+          constraints.push({ type: "before", a, b, axis: axisName });
+        } else if (rankB < rankA) {
+          constraints.push({ type: "before", a: b, b: a, axis: axisName });
+        }
+
+        // exact_distance
+        if (numVals) {
+          const valDist = Math.abs(numVals[rankA] - numVals[rankB]);
+          if (valDist > 0) {
             constraints.push({
-              type: "between",
-              outer1: v1,
-              middle: vals[m],
-              outer2: v2,
+              type: "exact_distance",
+              a,
+              b,
+              distance: valDist,
+              axis: axisName,
             });
-          } else {
+          }
+        } else {
+          const dist = Math.abs(rankA - rankB);
+          if (dist >= 2) {
             constraints.push({
-              type: "not_between",
-              outer1: v1,
-              middle: vals[m],
-              outer2: v2,
+              type: "exact_distance",
+              a,
+              b,
+              distance: dist,
+              axis: axisName,
             });
           }
-          if (++betweenCount >= maxBetween) continue outer;
+        }
+      }
+    }
+
+    // --- Per-axis between / not_between (triples) ---
+    // Cap to O(n²) emissions per axis to match the single-axis budget.
+    const maxBetween = n * n;
+    let betweenCount = 0;
+    betweenOuter: for (
+      let i = 0;
+      i < allValues.length && betweenCount < maxBetween;
+      i++
+    ) {
+      if (catArr[i] === axisCatIdx) continue;
+      const ai = allValues[i];
+      const catAi = catArr[i];
+      const rankAi = rankAtRow[posArr[i]];
+      for (
+        let j = i + 1;
+        j < allValues.length && betweenCount < maxBetween;
+        j++
+      ) {
+        if (catArr[j] === axisCatIdx) continue;
+        if (catArr[j] === catAi) continue;
+        const aj = allValues[j];
+        const catAj = catArr[j];
+        const rankAj = rankAtRow[posArr[j]];
+        for (let k = j + 1; k < allValues.length; k++) {
+          if (catArr[k] === axisCatIdx) continue;
+          if (catArr[k] === catAi || catArr[k] === catAj) continue;
+          const ak = allValues[k];
+          const rankAk = rankAtRow[posArr[k]];
+          const vals = [ai, aj, ak];
+          const ranks = [rankAi, rankAj, rankAk];
+          for (let m = 0; m < 3; m++) {
+            const o0 = m === 0 ? 1 : 0;
+            const o1 = m === 2 ? 1 : 2;
+            const lo = Math.min(ranks[o0], ranks[o1]);
+            const hi = Math.max(ranks[o0], ranks[o1]);
+            const [v1, v2] =
+              vals[o0] < vals[o1] ? [vals[o0], vals[o1]] : [vals[o1], vals[o0]];
+            if (ranks[m] > lo && ranks[m] < hi) {
+              constraints.push({
+                type: "between",
+                outer1: v1,
+                middle: vals[m],
+                outer2: v2,
+                axis: axisName,
+              });
+            } else {
+              constraints.push({
+                type: "not_between",
+                outer1: v1,
+                middle: vals[m],
+                outer2: v2,
+                axis: axisName,
+              });
+            }
+            if (++betweenCount >= maxBetween) continue betweenOuter;
+          }
         }
       }
     }
   }
 
-  // Position constraints (skip position category values — their assignments are trivially known)
-  const posCatValues =
-    posCatIndex >= 0 ? new Set(grid.categories[posCatIndex].values) : undefined;
+  // --- Position constraints ---
+  // Skip values in the first ordered category — identity pinning makes their
+  // rows trivially determined by encodeBase's identity pinning.
+  const firstOrdered = orderedCats[0];
+  const firstOrderedValues = new Set(firstOrdered.values);
   for (const [val, pos] of posOf) {
-    if (posCatValues?.has(val)) continue;
+    if (firstOrderedValues.has(val)) continue;
     constraints.push({ type: "at_position", value: val, position: pos });
     for (let p = 0; p < n; p++) {
       if (p !== pos) {
@@ -525,7 +529,7 @@ function minimizeConstraints(
   }
   shuffle(rotation, rng);
 
-  // Phase 1: Constructive — add one constraint per rotation slot until unique
+  // Constructive phase: add one constraint per rotation slot until unique
   const cursors = new Map<string, number>();
   for (const type of byType.keys()) cursors.set(type, 0);
 
@@ -554,7 +558,7 @@ function minimizeConstraints(
   /* v8 ignore next */
   if (!unique) return [];
 
-  // Phase 2: Destructive trim — remove redundant in random order,
+  // Destructive trim: remove redundant in random order,
   // but keep constraints needed to avoid proof-by-contradiction.
   const activeIndices: number[] = [];
   for (let i = 0; i < total; i++) if (active[i]) activeIndices.push(i);
diff --git a/packages/logic-grid/src/grid-utils.test.ts b/packages/logic-grid/src/grid-utils.test.ts
index 6a35d3d..9b58247 100644
--- a/packages/logic-grid/src/grid-utils.test.ts
+++ b/packages/logic-grid/src/grid-utils.test.ts
@@ -1,134 +1,14 @@
 import { describe, it, expect } from "vitest";
-import {
-  findPositionCategory,
-  positionLabel,
-  posNoun,
-  posNounPlural,
-  posPrep,
-} from "./grid-utils";
-import { makeGrid } from "./test-helpers";
-import { generate } from "./generator";
+import { ordinal } from "./grid-utils";
 
-describe("findPositionCategory", () => {
-  it("returns undefined when no position category", () => {
-    const puzzle = generate({ size: 3, categories: 3, seed: 1 });
-    expect(findPositionCategory(puzzle.grid)).toBeUndefined();
+describe("ordinal", () => {
+  it("returns correct ordinals", () => {
+    expect(ordinal(0)).toBe("first");
+    expect(ordinal(7)).toBe("eighth");
   });
 
-  it("returns the position category", () => {
-    const puzzle = generate({
-      size: 3,
-      seed: 1,
-      categoryNames: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-        {
-          name: "Time",
-          values: ["7am", "8am", "9am"],
-          noun: "slot",
-          verb: ["is at", "is not at"],
-          isPosition: true,
-        },
-        {
-          name: "Color",
-          values: ["Red", "Blue", "Green"],
-          noun: "color",
-          verb: ["wears", "does not wear"],
-        },
-      ],
-    });
-    const cat = findPositionCategory(puzzle.grid);
-    expect(cat?.name).toBe("Time");
-  });
-});
-
-describe("positionLabel", () => {
-  it("returns position category value when present", () => {
-    const puzzle = generate({
-      size: 3,
-      seed: 1,
-      categoryNames: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-        {
-          name: "Time",
-          values: ["7am", "8am", "9am"],
-          noun: "slot",
-          verb: ["is at", "is not at"],
-          isPosition: true,
-        },
-        {
-          name: "Color",
-          values: ["Red", "Blue", "Green"],
-          noun: "color",
-          verb: ["wears", "does not wear"],
-        },
-      ],
-    });
-    expect(positionLabel(0, puzzle.grid)).toBe("7am");
-    expect(positionLabel(2, puzzle.grid)).toBe("9am");
-  });
-
-  it("returns ordinal house labels for classic grids", () => {
-    const puzzle = generate({ size: 3, categories: 3, seed: 1 });
-    expect(positionLabel(0, puzzle.grid)).toBe("the first house");
-    expect(positionLabel(2, puzzle.grid)).toBe("the third house");
-  });
-
-  it("uses custom positionNoun", () => {
-    const puzzle = generate({
-      size: 3,
-      categories: 3,
-      seed: 1,
-      positionNoun: ["seat", "seats"],
-    });
-    expect(positionLabel(1, puzzle.grid)).toBe("the second seat");
-  });
-});
-
-describe("posNoun / posNounPlural / posPrep", () => {
-  it("returns configured values", () => {
-    const grid = makeGrid({
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-      ],
-      positionNoun: ["seat", "seats"],
-      positionPreposition: "at",
-    });
-    expect(posNoun(grid)).toBe("seat");
-    expect(posNounPlural(grid)).toBe("seats");
-    expect(posPrep(grid)).toBe("at");
-  });
-
-  it("throws on empty positionNoun singular", () => {
-    const grid = makeGrid({
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-      ],
-      positionNoun: ["", "seats"],
-    });
-    expect(() => posNoun(grid)).toThrow(RangeError);
-  });
-
-  it("throws on empty positionNoun plural", () => {
-    const grid = makeGrid({
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-      ],
-      positionNoun: ["seat", ""],
-    });
-    expect(() => posNounPlural(grid)).toThrow(RangeError);
-  });
-
-  it("throws on empty positionPreposition", () => {
-    const grid = makeGrid({
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-      ],
-      positionPreposition: "",
-    });
-    expect(() => posPrep(grid)).toThrow(RangeError);
+  it("throws for out-of-range positions", () => {
+    expect(() => ordinal(8)).toThrow("out of supported range");
+    expect(() => ordinal(-1)).toThrow("out of supported range");
   });
 });
diff --git a/packages/logic-grid/src/grid-utils.ts b/packages/logic-grid/src/grid-utils.ts
index 59877db..2d96587 100644
--- a/packages/logic-grid/src/grid-utils.ts
+++ b/packages/logic-grid/src/grid-utils.ts
@@ -1,5 +1,3 @@
-import type { Category, Grid } from "./types";
-
 export const ORDINALS = [
   "first",
   "second",
@@ -16,29 +14,3 @@ export function ordinal(position: number): string {
   if (!o) throw new Error(`Position ${position} out of supported range (0–7)`);
   return o;
 }
-
-export function posNoun(grid: Grid): string {
-  const noun = grid.positionNoun[0];
-  if (!noun) throw new RangeError("positionNoun singular must be non-empty");
-  return noun;
-}
-export function posNounPlural(grid: Grid): string {
-  const noun = grid.positionNoun[1];
-  if (!noun) throw new RangeError("positionNoun plural must be non-empty");
-  return noun;
-}
-export function posPrep(grid: Grid): string {
-  const prep = grid.positionPreposition;
-  if (!prep) throw new RangeError("positionPreposition must be non-empty");
-  return prep;
-}
-
-/** Find the position category (isPosition: true), if any. */
-export function findPositionCategory(grid: Grid): Category | undefined {
-  return grid.categories.find((c) => c.isPosition);
-}
-
-/** Human-readable position label from the grid's pre-computed labels. */
-export function positionLabel(position: number, grid: Grid): string {
-  return grid.positionLabels[position];
-}
diff --git a/packages/logic-grid/src/index.test.ts b/packages/logic-grid/src/index.test.ts
index 6e628b3..cc856f1 100644
--- a/packages/logic-grid/src/index.test.ts
+++ b/packages/logic-grid/src/index.test.ts
@@ -48,12 +48,13 @@ describe("public API integration", () => {
     const constraints = [
       atPosition("Red", 0),
       samePosition("Red", "Cat"),
-      leftOf("Blue", "Green"),
+      leftOf("Blue", "Green", "House"),
     ];
     const solution = solve(constraints, grid);
     expect(solution).not.toBeNull();
-    expect(solution![0]["Red"]).toBe(0);
-    expect(solution![1]["Cat"]).toBe(0);
+    // House is categories[0], then Color, Pet
+    expect(solution![1]["Red"]).toBe(0);
+    expect(solution![2]["Cat"]).toBe(0);
   });
 
   it("renderClue produces text for generated puzzles", () => {
diff --git a/packages/logic-grid/src/index.ts b/packages/logic-grid/src/index.ts
index a04b95d..8da199c 100644
--- a/packages/logic-grid/src/index.ts
+++ b/packages/logic-grid/src/index.ts
@@ -1,5 +1,5 @@
 export { generate } from "./generator";
-export { DEFAULT_CONFIG } from "./default-config";
+export { DEFAULT_CATEGORIES, defaultHouseCategory } from "./default-config";
 export { solve, hasUniqueSolution } from "./solver";
 export { classify } from "./difficulty";
 export { deduce } from "./deduce";
@@ -19,15 +19,20 @@ export {
 } from "./clues/constraints";
 
 export { renderClue } from "./clues/templates";
-export { findPositionCategory, positionLabel } from "./grid-utils";
+export {
+  isOrdered,
+  resolveAxis,
+  orderedCategories,
+  axisRank,
+  displayAxisCategory,
+  validateConstraints,
+} from "./axis";
 
 export type {
   Category,
   OrderingPhrases,
   OrderingComparatorType,
-  ComparatorPhrase,
   ComparatorMap,
-  SpatialWords,
   Grid,
   Assignment,
   Solution,
diff --git a/packages/logic-grid/src/solver.test.ts b/packages/logic-grid/src/solver.test.ts
index 3ef307d..8fede80 100644
--- a/packages/logic-grid/src/solver.test.ts
+++ b/packages/logic-grid/src/solver.test.ts
@@ -4,20 +4,12 @@ import { makeGrid } from "./test-helpers";
 import type { Constraint } from "./types";
 
 /**
- * 3x3 puzzle: 3 houses, 3 categories
+ * 3x3 puzzle: auto-added House + 3 custom categories.
  *
- * Solution (verify by hand):
- *   Position 0: Red,   Cat,  Tea
- *   Position 1: Blue,  Dog,  Coffee
- *   Position 2: Green, Fish, Water
- *
- * Reasoning:
- *   - Red is at position 0 (at_position)
- *   - Red and Cat share a house → Cat=0
- *   - Blue is directly left of Green → Blue=1, Green=2 (can't be 0, that's Red)
- *   - Blue and Dog share a house → Dog=1, so Fish=2
- *   - Dog and Coffee share a house → Coffee=1
- *   - Tea is at position 0 (at_position) → Water=2
+ * Solution:
+ *   Row 0: first house, Red,   Cat,  Tea
+ *   Row 1: second house, Blue,  Dog,  Coffee
+ *   Row 2: third house, Green, Fish, Water
  */
 const grid3x3 = makeGrid({
   size: 3,
@@ -31,7 +23,7 @@ const grid3x3 = makeGrid({
 const puzzle3x3: Constraint[] = [
   { type: "at_position", value: "Red", position: 0 },
   { type: "same_position", a: "Red", b: "Cat" },
-  { type: "left_of", a: "Blue", b: "Green" },
+  { type: "left_of", a: "Blue", b: "Green", axis: "House" },
   { type: "same_position", a: "Blue", b: "Dog" },
   { type: "same_position", a: "Dog", b: "Coffee" },
   { type: "at_position", value: "Tea", position: 0 },
@@ -42,7 +34,8 @@ describe("solve", () => {
     const solution = solve(puzzle3x3, grid3x3);
     expect(solution).not.toBeNull();
 
-    const [colors, pets, drinks] = solution!;
+    // Auto-added House is categories[0], then Color, Pet, Drink.
+    const [, colors, pets, drinks] = solution!;
     expect(colors).toEqual({ Red: 0, Blue: 1, Green: 2 });
     expect(pets).toEqual({ Cat: 0, Dog: 1, Fish: 2 });
     expect(drinks).toEqual({ Tea: 0, Coffee: 1, Water: 2 });
@@ -66,31 +59,7 @@ describe("solve", () => {
   });
 });
 
-/**
- * 4x4 puzzle
- *
- * Solution (verify by hand):
- *   Position 0: Alice, Red,    Cat,  Tea
- *   Position 1: Bob,   Blue,   Dog,  Coffee
- *   Position 2: Carol, Green,  Fish, Milk
- *   Position 3: Dave,  Yellow, Bird, Water
- *
- * Reasoning:
- *   1. Alice=0 (at_position)
- *   2. Alice=Red → Red=0 (same_position)
- *   3. Alice=Tea → Tea=0 (same_position)
- *   4. Bob next to Alice(0) → Bob=1 (only adjacent position)
- *   5. Dave=Yellow (same_position). Remaining positions for Carol,Dave: {2,3}
- *   6. left_of(Blue,Green): Blue can't be 0 (Red). Options: (1,2) or (2,3).
- *      If (2,3): Yellow would need pos 1, but Bob=1. Contradiction.
- *      So Blue=1, Green=2 → Yellow=3 → Dave=3, Carol=2
- *   7. Carol=Fish → Fish=2 (same_position)
- *   8. Milk=2 (at_position) → Carol drinks Milk
- *   9. left_of(Dog,Fish): Fish=2, so Dog=1
- *  10. Dog=Coffee → Coffee=1 (same_position)
- *  11. Alice≠Bird (not_same_position) → Bird≠0 → Bird=3, Cat=0
- *      Remaining: Water=3
- */
+/** 4x4 puzzle with auto-added House. */
 const grid4x4 = makeGrid({
   size: 4,
   categories: [
@@ -105,13 +74,13 @@ const puzzle4x4: Constraint[] = [
   { type: "at_position", value: "Alice", position: 0 },
   { type: "same_position", a: "Alice", b: "Red" },
   { type: "same_position", a: "Alice", b: "Tea" },
-  { type: "next_to", a: "Bob", b: "Alice" },
+  { type: "next_to", a: "Bob", b: "Alice", axis: "House" },
   { type: "same_position", a: "Dave", b: "Yellow" },
-  { type: "left_of", a: "Blue", b: "Green" },
+  { type: "left_of", a: "Blue", b: "Green", axis: "House" },
   { type: "same_position", a: "Carol", b: "Fish" },
   { type: "at_position", value: "Milk", position: 2 },
   { type: "same_position", a: "Dog", b: "Coffee" },
-  { type: "left_of", a: "Dog", b: "Fish" },
+  { type: "left_of", a: "Dog", b: "Fish", axis: "House" },
   { type: "not_same_position", a: "Alice", b: "Bird" },
 ];
 
@@ -120,7 +89,8 @@ describe("solve 4x4", () => {
     const solution = solve(puzzle4x4, grid4x4);
     expect(solution).not.toBeNull();
 
-    const [names, colors, pets, drinks] = solution!;
+    // House, Name, Color, Pet, Drink
+    const [, names, colors, pets, drinks] = solution!;
     expect(names).toEqual({ Alice: 0, Bob: 1, Carol: 2, Dave: 3 });
     expect(colors).toEqual({ Red: 0, Blue: 1, Green: 2, Yellow: 3 });
     expect(pets).toEqual({ Cat: 0, Dog: 1, Fish: 2, Bird: 3 });
@@ -138,7 +108,6 @@ describe("hasUniqueSolution", () => {
   });
 
   it("returns false when a constraint is removed", () => {
-    // Remove last constraint — Blue/Dog link breaks, multiple solutions
     const weakened = puzzle3x3.slice(0, -1);
     expect(hasUniqueSolution(weakened, grid3x3)).toBe(false);
   });
diff --git a/packages/logic-grid/src/test-helpers.ts b/packages/logic-grid/src/test-helpers.ts
index 8b80676..656ae2e 100644
--- a/packages/logic-grid/src/test-helpers.ts
+++ b/packages/logic-grid/src/test-helpers.ts
@@ -1,34 +1,36 @@
-import type { Category, Grid, SpatialWords } from "./types";
-import { ORDINALS } from "./grid-utils";
-import { DEFAULT_CONFIG } from "./default-config";
+import type { Category, ComparatorMap, Grid } from "./types";
+import { defaultHouseCategory } from "./default-config";
+
+/** Generic comparators for test ordered categories. */
+export const TEST_COMPARATORS: ComparatorMap = {
+  before: ["is before", "is after"],
+  left_of: ["is right before", "is right after"],
+  next_to: "is right next to",
+  not_next_to: "is not right next to",
+  between: "is between",
+  not_between: "is not between",
+  exact_distance: "is exactly",
+};
 
 /**
- * Build a Grid from a minimal description, filling in default rendering fields.
- * For tests only — production code should use generate().
+ * Build a Grid from a minimal description. For tests only — production code
+ * should use generate().
+ *
+ * Prepends a default House ordered category if none of the supplied categories
+ * is ordered, matching the buildGrid behavior in generate().
  */
 export function makeGrid(partial: {
   size: number;
   categories: Category[];
-  positionNoun?: [string, string];
-  positionPreposition?: string;
-  spatialWords?: SpatialWords;
-  positionLabels?: string[];
+  displayAxis?: string;
 }): Grid {
-  const positionNoun = partial.positionNoun ?? DEFAULT_CONFIG.positionNoun;
-  const positionPreposition =
-    partial.positionPreposition ?? DEFAULT_CONFIG.positionPreposition;
-  const positionLabels =
-    partial.positionLabels ??
-    Array.from(
-      { length: partial.size },
-      (_, i) => `the ${ORDINALS[i]} ${positionNoun[0]}`,
-    );
+  let categories = partial.categories;
+  if (!categories.some((c) => c.ordered === true)) {
+    categories = [defaultHouseCategory(partial.size), ...categories];
+  }
   return {
     size: partial.size,
-    categories: partial.categories,
-    positionNoun,
-    positionPreposition,
-    spatialWords: partial.spatialWords ?? DEFAULT_CONFIG.spatialWords,
-    positionLabels,
+    categories,
+    displayAxis: partial.displayAxis,
   };
 }
diff --git a/packages/logic-grid/src/types.ts b/packages/logic-grid/src/types.ts
index da43c34..c9137bb 100644
--- a/packages/logic-grid/src/types.ts
+++ b/packages/logic-grid/src/types.ts
@@ -9,80 +9,111 @@ export type OrderingComparatorType =
   | "exact_distance";
 
 /**
- * Comparator phrase value. A plain string is forward-only ("a {phrase} b").
- * A tuple `[forward, reverse]` lets the renderer alternate phrasing for
- * directional constraints (`before`, `left_of`). Forward: "a {forward} b".
- * Reverse: "b {reverse} a". E.g. `["has a lower return than", "has a higher return than"]`.
+ * Comparator phrases for all 7 constraint types.
+ *
+ * Directional constraints (`before`, `left_of`) require a `[forward, reverse]`
+ * tuple for phrasing variety. The renderer picks which to use based on subject
+ * priority and a deterministic hash tiebreaker.
+ *   Forward: "Alice has a lower return than Bob."
+ *   Reverse: "Bob has a higher return than Alice."
+ *
+ * Symmetric constraints (`next_to`, `between`, etc.) are a plain string since
+ * both directions read the same.
  */
-export type ComparatorPhrase = string | [string, string];
-
-/** Map of constraint type → comparator phrase override. */
-export type ComparatorMap = Partial<
-  Record<OrderingComparatorType, ComparatorPhrase>
->;
+export interface ComparatorMap {
+  before: [string, string];
+  left_of: [string, string];
+  next_to: string;
+  not_next_to: string;
+  between: string;
+  not_between: string;
+  exact_distance: string;
+}
 
 /** Domain-specific phrasing for ordering constraints on a category. */
 export interface OrderingPhrases {
-  /** Singular/plural unit, e.g. `["hour", "hours"]` → "exactly two hours apart". */
+  /** Singular/plural unit for exact_distance, e.g. `["hour", "hours"]` → "exactly two hours apart". */
   unit?: [string, string];
-  /** Custom comparator phrases keyed by constraint type. */
-  comparators?: ComparatorMap;
-}
-
-/** Configurable words for composing ordering clue sentences. */
-export interface SpatialWords {
-  /** [positive, negative] verb. E.g. `["lives", "does not live"]` or `["is", "is not"]`. */
-  verb: [string, string];
-  /** Adjacency word for next_to / not_next_to. E.g. `"next to"` or `"adjacent to"`. */
-  adjacency: string;
-  /** [forward, reverse] directional words for left_of / before. E.g. `["left of", "right of"]` or `["before", "after"]`. */
-  direction: [string, string];
-  /** Suffix for between / not_between, composed with verb. E.g. `"somewhere between"` → "lives somewhere between". */
-  between: string;
-  /** [positive, negative] for at_position / not_at_position. E.g. `["lives in", "does not live in"]` or `["has an appointment at", "does not have an appointment at"]`. */
-  atPosition: [string, string];
-  /** Spelled-out cardinal numbers for exact_distance. */
-  cardinals: string[];
-  /** Full-phrase overrides per constraint type. Checked before composing from verb/direction/adjacency. */
-  comparators?: ComparatorMap;
-  /** Singular/plural distance unit override. When set, exact_distance uses this instead of positionNoun. */
-  distanceUnit?: [string, string];
+  /** Comparator phrases for all 7 comparative constraint types. Required. */
+  comparators: ComparatorMap;
 }
 
-/** A named group of values that occupy positions in the grid. */
-export interface Category {
+/** Shared fields on every category. */
+interface CategoryCore {
   name: string;
   values: string[];
   /** Noun for clue phrases. `"owner"` → "the cat owner". Empty string = bare value ("Alice"). */
   noun?: string;
-  /** Verb phrases for same-position clues: `[positive, negative]`. Include "the" if appropriate. E.g. `["drives the", "does not drive the"]`. */
-  verb?: [string, string];
   /** Subject priority for same-position clues. Higher = more likely to be the sentence subject. */
   subjectPriority?: number;
-  /** Suffix appended to the value in object position. E.g. `"strategy"` → "the event-driven strategy", `"house"` → "red house". */
-  valueSuffix?: string;
-  /** When this category's values describe the position noun directly (e.g. Color → "The first house is red"), provide the [positive, negative] verb pair for at_position inversion. */
-  positionAdjective?: [string, string];
-  /** When true, this category defines position labels. Assignment is identity (value[i] → position i). Values appear verbatim in clues as position labels (e.g. "Alice has a return of 6%") — keep them short and self-explanatory. */
-  isPosition?: boolean;
-  /** Actual numeric values per position, enabling value-based distance for `exact_distance`. Must match `values` length and be in ascending order. */
-  numericValues?: number[];
-  /** Domain-specific phrasing for ordering constraints. */
-  orderingPhrases?: OrderingPhrases;
 }
 
+/**
+ * Ordered / unordered discriminator.
+ *
+ * `ordered: true` implies:
+ * - `values` array defines the canonical total order (rank = array index).
+ * - The category may be referenced as `axis` on any comparative constraint.
+ * - `verb` is required (used for at_position rendering).
+ * - `numericValues` and `orderingPhrases` become legal.
+ * - The category participates in multi-axis generation, deduction, rendering.
+ */
+type OrderednessFields =
+  | {
+      ordered: true;
+      /** Verb phrases for same-position / at_position clues: `[positive, negative]`. Required on ordered categories. */
+      verb: [string, string];
+      /** Per-rank numeric values for non-equidistant `exact_distance`. Must match `values` length and be ascending. */
+      numericValues?: number[];
+      /** Domain-specific phrasing for ordering constraints on this axis. Required on all ordered categories. */
+      orderingPhrases: OrderingPhrases;
+      /** Optional display labels for UI (grid headers). When absent, `values` are used. Clue rendering always uses `values`. */
+      displayLabels?: string[];
+    }
+  | {
+      ordered?: false;
+      /** Verb phrases for same-position clues: `[positive, negative]`. Required when noun !== "" (runtime check). */
+      verb?: [string, string];
+      numericValues?: never;
+      orderingPhrases?: never;
+    };
+
+/**
+ * `positionAdjective` requires `valueSuffix`. Color-like categories
+ * ("The 1st house is red") need both: the suffix gives the object form,
+ * and the adjective verb pair gives the "is"/"is not" for same_position
+ * rendering when the other side is an ordered-category value.
+ */
+type ValueSuffixFields =
+  | {
+      /** Suffix appended to the value in object position. E.g. `"house"` → "red house". */
+      valueSuffix: string;
+      /** Verb pair used when this category's value appears with an ordered-category value on the other side. E.g. `["is", "is not"]`. */
+      positionAdjective?: [string, string];
+    }
+  | {
+      valueSuffix?: undefined;
+      positionAdjective?: undefined;
+    };
+
+/** A named group of values that occupy positions in the grid. */
+export type Category = CategoryCore & OrderednessFields & ValueSuffixFields;
+
+/** A Category known to be ordered (returned by resolveAxis). */
+export type OrderedCategory = CategoryCore & {
+  ordered: true;
+  verb: [string, string];
+  numericValues?: number[];
+  orderingPhrases: OrderingPhrases;
+  displayLabels?: string[];
+} & ValueSuffixFields;
+
 /** The puzzle board: `size` positions and one or more categories. */
 export interface Grid {
   size: number;
   categories: Category[];
-  /** Singular and plural position noun, e.g. `["house", "houses"]`. */
-  positionNoun: [string, string];
-  /** Preposition for positional phrases, e.g. `"in"` → "lives in the first house". */
-  positionPreposition: string;
-  /** Configurable words for composing ordering clue sentences. */
-  spatialWords: SpatialWords;
-  /** Human-readable position labels. E.g. `["the first house", ...]` or `["6%", "7%", ...]`. */
-  positionLabels: string[];
+  /** Optional hint for presentation layers: name of an ordered category to use as display anchor. If absent, presentation picks the first ordered category. */
+  displayAxis?: string;
 }
 
 /** Maps each value name to its 0-indexed position. One per category. */
@@ -96,18 +127,37 @@ export type ConstraintType = Constraint["type"];
 
 /**
  * A logical relationship between values. Discriminated union on `type`.
- * Positions are 0-indexed.
+ * Row indices are internal SAT bookkeeping; every comparative constraint
+ * references an ordered category via `axis`.
  */
 export type Constraint =
   | { type: "same_position"; a: string; b: string }
   | { type: "not_same_position"; a: string; b: string }
-  | { type: "next_to"; a: string; b: string }
-  | { type: "not_next_to"; a: string; b: string }
-  | { type: "left_of"; a: string; b: string }
-  | { type: "between"; outer1: string; middle: string; outer2: string }
-  | { type: "not_between"; outer1: string; middle: string; outer2: string }
-  | { type: "before"; a: string; b: string }
-  | { type: "exact_distance"; a: string; b: string; distance: number }
+  | { type: "next_to"; a: string; b: string; axis: string }
+  | { type: "not_next_to"; a: string; b: string; axis: string }
+  | { type: "left_of"; a: string; b: string; axis: string }
+  | {
+      type: "between";
+      outer1: string;
+      middle: string;
+      outer2: string;
+      axis: string;
+    }
+  | {
+      type: "not_between";
+      outer1: string;
+      middle: string;
+      outer2: string;
+      axis: string;
+    }
+  | { type: "before"; a: string; b: string; axis: string }
+  | {
+      type: "exact_distance";
+      a: string;
+      b: string;
+      distance: number;
+      axis: string;
+    }
   | { type: "at_position"; value: string; position: number }
   | { type: "not_at_position"; value: string; position: number };
 
@@ -184,8 +234,6 @@ export interface GenerateOptions {
   categoryNames?: Category[];
   /** Random seed for reproducible generation. */
   seed?: number;
-  /** Singular and plural position noun. Default: `["house", "houses"]`. */
-  positionNoun?: [string, string];
-  /** Preposition for positional phrases. Default: `"in"`. */
-  positionPreposition?: string;
+  /** Optional presentation hint naming an ordered category as display anchor. */
+  displayAxis?: string;
 }