From fb35f0739fb8b5c6cd806d86383ee064e51e5c24 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Thu, 9 Apr 2026 18:46:00 +0200
Subject: [PATCH 01/24] feat: add axis field for multi-ordered-category
 constraints (phase 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Introduce an `ordered` flag on Category and a required `axis` field on
comparative constraints (before, left_of, next_to, not_next_to, between,
not_between, exact_distance). `isPosition` is removed in favor of
`ordered: true` — at least one category per grid must be ordered, and
the auto-added House category fills that role when users provide none.

This is phase 1 of 5: the schema changes and test migration land now,
but the encoder, generator, deducer, and renderer still use row-based
logic. Phase 1 compensates by identity-pinning the first ordered
category in randomSolution, encodeBase, and createState so rows and
ranks agree for the default axis. Phase 2 will switch to rank-forbidding
encoding and remove the identity pinning.

Key additions:
- Category gains `ordered?: boolean` in a discriminated union that makes
  `numericValues` and `orderingPhrases` only legal on ordered categories.
- `positionAdjective` now requires `valueSuffix` via a union type.
- New axis.ts module: resolveAxis, orderedCategories, axisRank,
  displayAxisCategory, validateConstraints.
- Grid gains optional `displayAxis` hint (presentation concern).
- Grid loses `positionLabels` (derived on demand from first ordered
  category's values).
- SpatialWords keeps `atPosition` for the at_position render path.
- `renderSamePosition` gains a new rule: when one side has
  `positionAdjective` and the other is in an ordered category, render
  with the ordered value as subject and the adjective verb — recovering
  the classical Color+House "The first house is red" idiom from a plain
  same_position constraint.
- default-config.ts splits DEFAULT_CONFIG into DEFAULT_CATEGORIES,
  DEFAULT_SPATIAL_WORDS, DEFAULT_POSITION_NOUN, DEFAULT_POSITION_PREPOSITION,
  and exports `defaultHouseCategory(size)` for the auto-add.
- Generator's buildGrid auto-prepends the default House category as the
  first ordered slot (preserving total category count when the user
  asks for N categories without providing their own).
- logic-grid-ai: theme.ts schema and prompt replace `isPosition` with
  `ordered`, validation.ts rejects themes with no ordered category.
- Demo: PuzzleGrid and puzzle-state use `displayAxisCategory` instead of
  the removed `findPositionCategory`.

Multi-axis is not yet functional — the encoder/deducer/renderer only
consume the default (first ordered) axis in Phase 1. Phases 2-5 add
unified rank-forbidding encoding, multi-axis enumeration, rank-space
deduction, and per-axis rendering.
---
 packages/demo/src/lib/PuzzleGrid.svelte       |  10 +-
 packages/demo/src/lib/puzzle-state.svelte.ts  |  18 +-
 packages/demo/src/routes/+page.svelte         |  16 +-
 packages/logic-grid-ai/src/rewrite.test.ts    |   2 +-
 packages/logic-grid-ai/src/theme.test.ts      |   1 +
 packages/logic-grid-ai/src/theme.ts           |  23 +-
 packages/logic-grid-ai/src/validation.test.ts |  27 +-
 packages/logic-grid-ai/src/validation.ts      |  17 +-
 .../src/__snapshots__/index.test.ts.snap      |  18 +-
 packages/logic-grid/src/axis.ts               |  88 +++
 .../logic-grid/src/clues/constraints.test.ts  |  39 +-
 packages/logic-grid/src/clues/constraints.ts  |  43 +-
 .../logic-grid/src/clues/templates.test.ts    | 748 +++++-------------
 packages/logic-grid/src/clues/templates.ts    |  34 +-
 .../logic-grid/src/deduce/constraints.test.ts | 238 ++++--
 packages/logic-grid/src/deduce/constraints.ts |  13 +-
 packages/logic-grid/src/deduce/index.test.ts  |   2 +-
 .../logic-grid/src/deduce/propagate.test.ts   |  32 +-
 packages/logic-grid/src/deduce/state.test.ts  |  17 +-
 packages/logic-grid/src/deduce/state.ts       |  10 +
 .../logic-grid/src/deduce/structural.test.ts  |   4 +-
 packages/logic-grid/src/default-config.ts     | 298 +++----
 packages/logic-grid/src/difficulty.test.ts    |  52 +-
 packages/logic-grid/src/encoding.test.ts      |  62 +-
 packages/logic-grid/src/encoding.ts           |  16 +-
 packages/logic-grid/src/generator.test.ts     | 104 +--
 packages/logic-grid/src/generator.ts          | 236 +++---
 packages/logic-grid/src/grid-utils.test.ts    |  84 +-
 packages/logic-grid/src/grid-utils.ts         |  12 +-
 packages/logic-grid/src/index.test.ts         |   7 +-
 packages/logic-grid/src/index.ts              |  14 +-
 packages/logic-grid/src/solver.test.ts        |  59 +-
 packages/logic-grid/src/test-helpers.ts       |  33 +-
 packages/logic-grid/src/types.ts              | 105 ++-
 34 files changed, 1176 insertions(+), 1306 deletions(-)
 create mode 100644 packages/logic-grid/src/axis.ts

diff --git a/packages/demo/src/lib/PuzzleGrid.svelte b/packages/demo/src/lib/PuzzleGrid.svelte
index ceb8689..6d5ecad 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. Phase 1 identity-pins
+  // it, 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. */
diff --git a/packages/demo/src/lib/puzzle-state.svelte.ts b/packages/demo/src/lib/puzzle-state.svelte.ts
index 13e8efa..8587b10 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,
@@ -135,15 +135,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 assignment in Phase 1)
+        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 = [];
diff --git a/packages/demo/src/routes/+page.svelte b/packages/demo/src/routes/+page.svelte
index 5fccd70..7912237 100644
--- a/packages/demo/src/routes/+page.svelte
+++ b/packages/demo/src/routes/+page.svelte
@@ -26,16 +26,16 @@
           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"],
+            unit: ["percentage point", "percentage points"] as [string, string],
             comparators: {
-              before: ["has a lower return than", "has a higher return than"],
+              before: ["has a lower return than", "has a higher return than"] as [string, string],
               left_of: [
                 "has the next lower return than",
                 "has the next higher return than",
-              ],
+              ] as [string, string],
               next_to: "has an adjacent return to",
               not_next_to: "does not have an adjacent return to",
               between: "has a return somewhere between",
@@ -61,19 +61,19 @@
           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"],
+            unit: ["hour", "hours"] as [string, string],
             comparators: {
               before: [
                 "has an earlier appointment than",
                 "has a later appointment than",
-              ],
+              ] as [string, string],
               left_of: [
                 "has an appointment exactly one hour before",
                 "has an appointment exactly one hour after",
-              ],
+              ] as [string, string],
               next_to: "has an appointment within one hour of",
               not_next_to: "does not have an appointment within one hour of",
               between: "has an appointment somewhere between",
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..f6a61ed 100644
--- a/packages/logic-grid-ai/src/theme.test.ts
+++ b/packages/logic-grid-ai/src/theme.test.ts
@@ -22,6 +22,7 @@ const VALID_THEME: ThemeResult = {
       values: ["Galleon", "Brigantine", "Sloop", "Frigate"],
       noun: "captain",
       verb: ["sails the", "does not sail the"],
+      ordered: true,
     },
     {
       name: "Treasure",
diff --git a/packages/logic-grid-ai/src/theme.ts b/packages/logic-grid-ai/src/theme.ts
index 6b911bc..20bdc8a 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",
@@ -149,18 +149,13 @@ The puzzle has ${size} positions. Clues are generated mechanically from categori
 
 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.
 
-## Position categories (optional, advanced)
+## Ordered categories
 
-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
+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 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."
+- 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"]\`.
 
 ## Examples
 
@@ -184,7 +179,7 @@ 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 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": "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"] }
   ],
@@ -199,7 +194,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
 
diff --git a/packages/logic-grid-ai/src/validation.test.ts b/packages/logic-grid-ai/src/validation.test.ts
index 43504f9..0c97de8 100644
--- a/packages/logic-grid-ai/src/validation.test.ts
+++ b/packages/logic-grid-ai/src/validation.test.ts
@@ -15,6 +15,7 @@ function validResult(): ThemeResult {
         values: ["Risotto", "Soufflé", "Ramen"],
         noun: "chef",
         verb: ["prepares the", "does not prepare the"],
+        ordered: true,
       },
       {
         name: "Tool",
@@ -223,9 +224,8 @@ describe("validateThemeResult", () => {
     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 = {
       unit: ["point", "points"],
@@ -234,14 +234,10 @@ describe("validateThemeResult", () => {
     expect(validateThemeResult(r, 3, 3)).toEqual([]);
   });
 
-  it("rejects multiple position categories", () => {
+  it("accepts multiple ordered categories", () => {
     const r = validResult();
-    r.categories[1].isPosition = true;
-    r.categories[2].isPosition = true;
-    const errors = validateThemeResult(r, 3, 3);
-    expect(errors).toContainEqual(
-      expect.stringContaining("Multiple position categories"),
-    );
+    r.categories[2].ordered = true;
+    expect(validateThemeResult(r, 3, 3)).toEqual([]);
   });
 
   it("rejects numericValues with wrong count", () => {
@@ -380,19 +376,6 @@ describe("validateThemeResult", () => {
     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
diff --git a/packages/logic-grid-ai/src/validation.ts b/packages/logic-grid-ai/src/validation.ts
index 27e2036..9ef5cba 100644
--- a/packages/logic-grid-ai/src/validation.ts
+++ b/packages/logic-grid-ai/src/validation.ts
@@ -34,7 +34,7 @@ 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) {
     const name = cat.name ?? "";
@@ -121,9 +121,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 +193,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,9 +214,9 @@ 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.",
     );
   }
 
diff --git a/packages/logic-grid/src/__snapshots__/index.test.ts.snap b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
index d1f43c1..b8e28c8 100644
--- a/packages/logic-grid/src/__snapshots__/index.test.ts.snap
+++ b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
@@ -2,17 +2,13 @@
 
 exports[`public API integration > generate with custom noun/verb produces correct clues 1`] = `
 [
-  "Kai does not live next to the italian speaker.",
+  "The tulip grower lives in the second house.",
+  "The italian speaker plays the piano.",
+  "The rose grower lives directly left of the violin player.",
+  "Kai lives somewhere right of the daisy grower.",
+  "The guitar player lives in the second house.",
+  "The french speaker lives in the third house.",
   "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.",
-  "The guitar player grows the tulip.",
+  "Luna lives exactly three houses from the first house.",
 ]
 `;
diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
new file mode 100644
index 0000000..8deaa1b
--- /dev/null
+++ b/packages/logic-grid/src/axis.ts
@@ -0,0 +1,88 @@
+import type { Category, Constraint, Grid } from "./types";
+
+/**
+ * Return the list of `ordered: true` categories in declaration order.
+ * These are the axes available to comparative constraints.
+ */
+export function orderedCategories(grid: Grid): Category[] {
+  return grid.categories.filter((c) => c.ordered === true);
+}
+
+/**
+ * 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): Category {
+  const cat = grid.categories.find((c) => c.name === axisName);
+  if (!cat) {
+    throw new RangeError(`Unknown axis: "${axisName}"`);
+  }
+  if (cat.ordered !== true) {
+    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): Category {
+  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;
+}
+
+/** Constraint types that carry an `axis` field. */
+const AXIS_CONSTRAINT_TYPES = new Set([
+  "next_to",
+  "not_next_to",
+  "left_of",
+  "between",
+  "not_between",
+  "before",
+  "exact_distance",
+]);
+
+/**
+ * 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_CONSTRAINT_TYPES.has(c.type)) {
+      const axisName = (c as { axis: string }).axis;
+      resolveAxis(grid, axisName);
+    }
+  }
+}
diff --git a/packages/logic-grid/src/clues/constraints.test.ts b/packages/logic-grid/src/clues/constraints.test.ts
index 5150dc6..0c4810f 100644
--- a/packages/logic-grid/src/clues/constraints.test.ts
+++ b/packages/logic-grid/src/clues/constraints.test.ts
@@ -9,8 +9,6 @@ import {
   notBetween,
   before,
   exactDistance,
-  atPosition,
-  notAtPosition,
 } from "./constraints";
 
 describe("constraint factories", () => {
@@ -31,77 +29,68 @@ 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,
-    });
-  });
-
-  it("notAtPosition", () => {
-    expect(notAtPosition("Red", 2)).toEqual({
-      type: "not_at_position",
-      value: "Red",
-      position: 2,
+      axis: "House",
     });
   });
 });
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..7aabacf 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -1,18 +1,9 @@
 import { describe, it, expect } from "vitest";
 import { renderClue } from "./templates";
-import { DEFAULT_CONFIG } from "../default-config";
+import { DEFAULT_SPATIAL_WORDS } 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"],
-};
-
 const grid = makeGrid({
   size: 3,
   categories: [
@@ -46,11 +37,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 +72,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 +203,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 +217,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 +224,7 @@ describe("renderClue", () => {
         outer1: "Red",
         middle: "Cat",
         outer2: "Blue",
+        axis: "House",
       },
       grid,
     );
@@ -237,24 +233,23 @@ 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(
@@ -264,33 +259,17 @@ describe("renderClue", () => {
 
   it("exact_distance singular", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 1 },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Cat",
+        distance: 1,
+        axis: "House",
+      },
       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" },
-      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);
-  });
 });
 
 describe("custom category noun/verb", () => {
@@ -310,8 +289,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,493 +299,140 @@ 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({
-    size: 3,
-    categories: [
-      {
-        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"],
-        noun: "owner",
-        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",
+describe("grid-level comparator overrides", () => {
+  const withComparators: Grid = {
+    ...grid,
     spatialWords: {
-      ...DEFAULT_CONFIG.spatialWords,
-      atPosition: ["lives at", "does not live at"],
+      ...grid.spatialWords,
+      comparators: {
+        before: "comes earlier than",
+        left_of: "is directly before",
+        next_to: "is adjacent to",
+        not_next_to: "is not adjacent to",
+        between: "is between",
+        not_between: "is not between",
+        exact_distance: "is exactly",
+      },
     },
-    positionLabels: ["the first seat", "the second seat", "the third seat"],
-  });
-
-  it("at_position uses custom noun and preposition", () => {
-    const clue = renderClue(
-      { type: "at_position", value: "Tea", position: 0 },
-      seatGrid,
-    );
-    expect(clue.text).toBe("The tea drinker lives at the first seat.");
-  });
+  };
 
-  it("at_position with color uses custom noun", () => {
-    const clue = renderClue(
-      { type: "at_position", value: "Red", position: 2 },
-      seatGrid,
-    );
-    expect(clue.text).toBe("The third seat is red.");
-  });
-
-  it("not_at_position uses custom noun and preposition", () => {
+  it("before uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "not_at_position", value: "Alice", position: 1 },
-      seatGrid,
+      { type: "before", a: "Alice", b: "Bob", axis: "House" },
+      withComparators,
     );
-    expect(clue.text).toBe("Alice does not live at the second seat.");
+    expect(clue.text).toBe("Alice comes earlier than Bob.");
   });
 
-  it("not_at_position with color uses custom noun", () => {
+  it("next_to uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "not_at_position", value: "Red", position: 2 },
-      seatGrid,
+      { type: "next_to", a: "Alice", b: "Bob", axis: "House" },
+      withComparators,
     );
-    expect(clue.text).toBe("The third seat is not red.");
-  });
-
-  it("exact_distance singular uses custom noun", () => {
-    const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 1 },
-      seatGrid,
+    expect(clue.text).toMatch(
+      /^(Alice is adjacent to Bob|Bob is adjacent to Alice)\.$/,
     );
-    expect(clue.text).toBe("Alice lives exactly one seat from the cat owner.");
   });
 
-  it("exact_distance plural uses custom noun", () => {
+  it("between uses grid comparator when set", () => {
     const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Cat", distance: 2 },
-      seatGrid,
+      {
+        type: "between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "House",
+      },
+      withComparators,
     );
-    expect(clue.text).toBe("Alice lives exactly two seats from the cat owner.");
+    expect(clue.text).toBe("Bob is between Alice and Carol.");
   });
+});
 
-  it("same_position color + pet uses custom noun and preposition", () => {
-    const clue = renderClue(
-      { type: "same_position", a: "Red", b: "Cat" },
-      seatGrid,
-    );
-    expect(clue.text).toBe("The cat owner lives at the red seat.");
-  });
+describe("before with tuple comparator picks forward or reverse", () => {
+  const withTuple: Grid = {
+    ...grid,
+    spatialWords: {
+      ...grid.spatialWords,
+      comparators: {
+        before: ["has a lower return than", "has a higher return than"],
+      },
+    },
+  };
 
-  it("same_position name + color uses custom noun and preposition", () => {
-    const clue = renderClue(
-      { type: "same_position", a: "Alice", b: "Blue" },
-      seatGrid,
+  it("picks forward or reverse phrase deterministically", () => {
+    const aliceBob = renderClue(
+      { type: "before", a: "Alice", b: "Bob", axis: "House" },
+      withTuple,
     );
-    expect(clue.text).toBe("Alice lives at the blue seat.");
-  });
-
-  it("not_same_position color + pet uses custom noun and preposition", () => {
-    const clue = renderClue(
-      { type: "not_same_position", a: "Red", b: "Cat" },
-      seatGrid,
+    expect(aliceBob.text).toMatch(
+      /^(Alice has a lower return than Bob|Bob has a higher return than Alice)\.$/,
     );
-    expect(clue.text).toBe("The cat owner does not live at the red seat.");
-  });
-
-  it("not_same_position color + drink uses custom noun", () => {
-    const clue = renderClue(
-      { type: "not_same_position", a: "Blue", b: "Coffee" },
-      seatGrid,
+    // Deterministic: same input → same output.
+    const again = renderClue(
+      { type: "before", a: "Alice", b: "Bob", axis: "House" },
+      withTuple,
     );
-    expect(clue.text).toBe(
-      "The coffee drinker does not live at the blue seat.",
-    );
-  });
-
-  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(again.text).toBe(aliceBob.text);
   });
 });
 
-describe("position category", () => {
-  const posGrid = makeGrid({
-    size: 3,
-    categories: [
-      { name: "Manager", values: ["Alice", "Bob", "Carol"], noun: "" },
-      {
-        name: "Return",
-        values: ["6%", "7%", "8%"],
-        noun: "fund",
-        isPosition: true,
-        numericValues: [6, 7, 8],
-        orderingPhrases: {
-          unit: ["percentage point", "percentage points"],
-          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",
-            between: "has a return between",
-            not_between: "does not have a return between",
-          },
-        },
-      },
-      {
-        name: "Strategy",
-        values: ["Long/Short", "Macro", "Quant"],
-        noun: "strategist",
-      },
-    ],
-    positionNoun: ["fund", "funds"],
-    positionPreposition: "at",
+describe("distance unit from spatialWords.distanceUnit", () => {
+  const withUnit: Grid = {
+    ...grid,
     spatialWords: {
-      ...POSITIONAL_WORDS,
+      ...grid.spatialWords,
       distanceUnit: ["percentage point", "percentage points"],
     },
-    positionLabels: ["6%", "7%", "8%"],
-  });
-
-  it("at_position uses position category label", () => {
-    const clue = renderClue(
-      { type: "at_position", value: "Alice", position: 0 },
-      posGrid,
-    );
-    expect(clue.text).toBe("Alice is at 6%.");
-  });
+  };
 
-  it("not_at_position uses position category label", () => {
+  it("exact_distance singular", () => {
     const clue = renderClue(
-      { type: "not_at_position", value: "Alice", position: 2 },
-      posGrid,
-    );
-    expect(clue.text).toBe("Alice is not at 8%.");
-  });
-
-  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",
-          ],
-        },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Cat",
+        distance: 1,
+        axis: "House",
       },
-    };
-    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", () => {
-    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)\.$/,
-    );
-  });
-
-  it("exact_distance singular unit", () => {
-    const clue = renderClue(
-      { type: "exact_distance", a: "Alice", b: "Bob", distance: 1 },
-      posGrid,
+      withUnit,
     );
-    expect(clue.text).toMatch(
-      /^(Alice|Bob) is exactly 1 percentage point from (Alice|Bob)\.$/,
-    );
-  });
-
-  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", () => {
-    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)\.$/,
-    );
-  });
-
-  it("between uses ordering templates", () => {
-    const clue = renderClue(
-      { type: "between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      posGrid,
-    );
-    expect(clue.text).toBe("Bob is somewhere between Alice and Carol.");
-  });
-
-  it("not_between uses ordering templates", () => {
-    const clue = renderClue(
-      { type: "not_between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      posGrid,
+    expect(clue.text).toBe(
+      "Alice lives exactly 1 percentage point from the cat owner.",
     );
-    expect(clue.text).toBe("Bob is not somewhere between Alice and Carol.");
   });
 
-  it("between uses grid comparator when set", () => {
-    const g: Grid = {
-      ...posGrid,
-      spatialWords: {
-        ...posGrid.spatialWords,
-        comparators: {
-          ...posGrid.spatialWords.comparators,
-          between: "has a return between",
-        },
-      },
-    };
+  it("exact_distance plural", () => {
     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("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",
-        },
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Cat",
+        distance: 2,
+        axis: "House",
       },
-    };
-    const clue = renderClue(
-      { type: "not_between", outer1: "Alice", middle: "Bob", outer2: "Carol" },
-      g,
+      withUnit,
     );
     expect(clue.text).toBe(
-      "Bob does not have a return between Alice and Carol.",
+      "Alice lives exactly 2 percentage points from the cat owner.",
     );
   });
 });
+
+describe("default spatial words sanity", () => {
+  it("DEFAULT_SPATIAL_WORDS has expected shape", () => {
+    const w: SpatialWords = DEFAULT_SPATIAL_WORDS;
+    expect(w.verb).toEqual(["lives", "does not live"]);
+    expect(w.adjacency).toBe("next to");
+    expect(w.direction).toEqual(["left of", "right of"]);
+    expect(w.between).toBe("somewhere between");
+    expect(w.cardinals.length).toBeGreaterThanOrEqual(4);
+  });
+});
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 018c0d1..e0652c3 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -6,6 +6,7 @@ import type {
   OrderingComparatorType,
 } from "../types";
 import { posNoun, posNounPlural } from "../grid-utils";
+import { orderedCategories } from "../axis";
 
 function findCategory(value: string, grid: Grid): Category {
   for (const cat of grid.categories) {
@@ -101,9 +102,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(
@@ -189,7 +204,7 @@ function renderText(constraint: Constraint, grid: Grid): string {
       return `${capitalize(la)} ${prefix} ${dist} ${noun} from ${lb}.`;
     }
     case "at_position": {
-      const posLabel = grid.positionLabels[constraint.position];
+      const posLabel = positionLabel(grid, constraint.position);
       const cat = findCategory(constraint.value, grid);
       if (cat.positionAdjective) {
         return `${capitalize(posLabel)} ${cat.positionAdjective[0]} ${constraint.value.toLowerCase()}.`;
@@ -197,7 +212,7 @@ function renderText(constraint: Constraint, grid: Grid): string {
       return `${capitalize(label(constraint.value, grid))} ${w.atPosition[0]} ${posLabel}.`;
     }
     case "not_at_position": {
-      const posLabel = grid.positionLabels[constraint.position];
+      const posLabel = positionLabel(grid, constraint.position);
       const cat = findCategory(constraint.value, grid);
       if (cat.positionAdjective) {
         return `${capitalize(posLabel)} ${cat.positionAdjective[1]} ${constraint.value.toLowerCase()}.`;
@@ -207,6 +222,19 @@ function renderText(constraint: Constraint, grid: Grid): string {
   }
 }
 
+/**
+ * Derive a human-readable label for row `position`. Reads from the first
+ * ordered category's value at that index (identity-assigned in Phase 1).
+ * Falls back to a generic "the Nth <positionNoun>" phrasing.
+ */
+function positionLabel(grid: Grid, position: number): string {
+  const axis = orderedCategories(grid)[0];
+  if (axis) {
+    return label(axis.values[position], grid);
+  }
+  return `the ${capitalize(posNoun(grid))} at position ${position + 1}`;
+}
+
 function capitalize(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
diff --git a/packages/logic-grid/src/deduce/constraints.test.ts b/packages/logic-grid/src/deduce/constraints.test.ts
index edab28c..ef33673 100644
--- a/packages/logic-grid/src/deduce/constraints.test.ts
+++ b/packages/logic-grid/src/deduce/constraints.test.ts
@@ -72,7 +72,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 +86,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 +98,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 +113,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 +146,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 +156,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 +169,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 +203,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 +236,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 +249,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 +260,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 +274,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 +290,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 +327,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");
@@ -333,7 +345,13 @@ describe("deduce constraint types", () => {
   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,7 +371,7 @@ 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],
         },
       ],
@@ -362,7 +380,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 +406,20 @@ 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],
         },
       ],
     });
     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 +433,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 +448,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 spatialWords", () => {
     const unitGrid = makeGrid({
       size: 4,
       categories: [
@@ -421,22 +457,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"],
-          },
         },
       ],
       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 +492,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"],
-          },
         },
       ],
       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 +529,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 +556,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 +591,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 +610,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 +632,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 +655,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 +693,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 +726,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 +744,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 +765,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 +784,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 +818,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 +839,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 +860,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 +876,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 +893,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 +910,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();
diff --git a/packages/logic-grid/src/deduce/constraints.ts b/packages/logic-grid/src/deduce/constraints.ts
index 2f94b9d..f007622 100644
--- a/packages/logic-grid/src/deduce/constraints.ts
+++ b/packages/logic-grid/src/deduce/constraints.ts
@@ -1,11 +1,6 @@
 import type { Constraint, DeductionStep, DeductionTechnique } from "../types";
-import {
-  ordinal,
-  posNoun,
-  posNounPlural,
-  posPrep,
-  findPositionCategory,
-} from "../grid-utils";
+import { ordinal, posNoun, posNounPlural, posPrep } from "../grid-utils";
+import { resolveAxis } from "../axis";
 import {
   type DeduceState,
   SILENT_STEP,
@@ -554,14 +549,14 @@ function tryNotBetween(
 
 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 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 = resolveAxis(state.grid, c.axis).numericValues;
 
   if (numVals) {
     // Value-based distance: compute valid partner positions from numeric values
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..225adbc 100644
--- a/packages/logic-grid/src/deduce/state.test.ts
+++ b/packages/logic-grid/src/deduce/state.test.ts
@@ -61,27 +61,28 @@ describe("describeResult", () => {
 });
 
 describe("describeKnown", () => {
+  // makeGrid auto-prepends a House category; Name is now categories[1].
   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);
+    // Pin Alice (categories[1] = Name, values[0] = "Alice") to position 0
+    state.possible[1][0].clear();
+    state.possible[1][0].add(0);
     expect(describeKnown(state, "Alice")).toBe("Alice is in the first house");
   });
 
   it("uses custom noun and preposition for assigned value", () => {
     const state = createState(seatGrid);
-    state.possible[0][0].clear();
-    state.possible[0][0].add(0);
+    state.possible[1][0].clear();
+    state.possible[1][0].add(0);
     expect(describeKnown(state, "Alice")).toBe("Alice is at the first seat");
   });
 
   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);
+    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",
     );
diff --git a/packages/logic-grid/src/deduce/state.ts b/packages/logic-grid/src/deduce/state.ts
index 2262632..f61a688 100644
--- a/packages/logic-grid/src/deduce/state.ts
+++ b/packages/logic-grid/src/deduce/state.ts
@@ -82,6 +82,16 @@ export function createState(grid: Grid): DeduceState {
       valueInfo.set(grid.categories[ci].values[vi], [ci, vi]);
     }
   }
+  // Phase 1: identity-pin the first ordered category to match randomSolution
+  // and encodeBase behavior. Phase 2 removes this.
+  const firstOrderedIdx = grid.categories.findIndex((c) => c.ordered === true);
+  if (firstOrderedIdx >= 0) {
+    const cat = grid.categories[firstOrderedIdx];
+    for (let vi = 0; vi < cat.values.length; vi++) {
+      possible[firstOrderedIdx][vi].clear();
+      possible[firstOrderedIdx][vi].add(vi);
+    }
+  }
   return { grid, n, possible, valueInfo, silent: false };
 }
 
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/default-config.ts b/packages/logic-grid/src/default-config.ts
index 67737be..9df6e42 100644
--- a/packages/logic-grid/src/default-config.ts
+++ b/packages/logic-grid/src/default-config.ts
@@ -1,146 +1,158 @@
-import type { Grid } from "./types";
+import type { Category, SpatialWords } 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",
+    ],
+  },
+];
+
+/** Generic fallback vocabulary used when an axis category supplies no overrides. */
+export const DEFAULT_SPATIAL_WORDS: 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 singular/plural position noun for the auto-added House category's display. */
+export const DEFAULT_POSITION_NOUN: [string, string] = ["house", "houses"];
+
+/** Default preposition for positional phrases. */
+export const DEFAULT_POSITION_PREPOSITION = "in";
+
+/**
+ * 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),
+  };
+}
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..282cf66 100644
--- a/packages/logic-grid/src/encoding.test.ts
+++ b/packages/logic-grid/src/encoding.test.ts
@@ -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,7 +274,8 @@ 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],
         },
       ],
@@ -259,19 +283,23 @@ describe("encodeConstraint", () => {
     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);
     }
   });
diff --git a/packages/logic-grid/src/encoding.ts b/packages/logic-grid/src/encoding.ts
index 9ff06bb..19f5d0a 100644
--- a/packages/logic-grid/src/encoding.ts
+++ b/packages/logic-grid/src/encoding.ts
@@ -1,5 +1,5 @@
 import type { Constraint, Grid } from "./types";
-import { findPositionCategory } from "./grid-utils";
+import { resolveAxis } from "./axis";
 
 /** Holds grid metadata needed to map values/positions to SAT variables. */
 export interface EncodingContext {
@@ -80,6 +80,17 @@ export function encodeBase(ctx: EncodingContext): number[][] {
     }
   }
 
+  // Phase 1: identity-pin the first ordered category. This matches the
+  // generator's randomSolution behavior and keeps the row-based encoder
+  // semantically consistent with the axis-tagged comparative constraints.
+  // Phase 2 removes this when the encoder switches to rank-forbidding.
+  const firstOrdered = grid.categories.find((c) => c.ordered === true);
+  if (firstOrdered) {
+    for (let i = 0; i < firstOrdered.values.length; i++) {
+      clauses.push([variable(ctx, firstOrdered.values[i], i)]);
+    }
+  }
+
   return clauses;
 }
 
@@ -244,7 +255,8 @@ export function encodeConstraint(
     case "exact_distance": {
       const { a, b, distance } = constraint;
       const clauses: number[][] = [];
-      const numVals = findPositionCategory(ctx.grid)?.numericValues;
+      const axis = resolveAxis(ctx.grid, constraint.axis);
+      const numVals = axis.numericValues;
 
       if (numVals) {
         // Value-based distance: find position pairs where numeric values differ by distance
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index bc716c1..4b7b045 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -193,6 +193,7 @@ describe("generate", () => {
           values: ["A", "B", "C"],
           noun: "house",
           verb: ["lives in", "does not live in"],
+          ordered: true,
         },
         {
           name: "Owner",
@@ -369,54 +370,6 @@ describe("generate", () => {
     ).toThrow("requires a verb");
   });
 
-  it("throws when position category lacks verb", () => {
-    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: "Color",
-            values: ["Red", "Blue", "Green"],
-            noun: "house",
-            verb: ["lives in the", "does not live in the"],
-          },
-        ],
-      }),
-    ).toThrow("Position category");
-  });
-
-  it("throws when more than one category is isPosition", () => {
-    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,
-          },
-        ],
-      }),
-    ).toThrow("At most one category can have isPosition");
-  });
-
   it("throws when symmetric comparator is a tuple", () => {
     expect(() =>
       generate({
@@ -428,10 +381,10 @@ describe("generate", () => {
             values: ["7am", "8am", "9am"],
             noun: "slot",
             verb: ["is at", "is not at"],
-            isPosition: true,
+            ordered: true,
             orderingPhrases: {
               comparators: {
-                next_to: ["fwd", "rev"],
+                next_to: ["fwd", "rev"] as [string, string],
               },
             },
           },
@@ -446,25 +399,6 @@ describe("generate", () => {
     ).toThrow('comparator "next_to" is symmetric');
   });
 
-  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");
-  });
-
   it("throws when numericValues are not in ascending order", () => {
     expect(() =>
       generate({
@@ -474,7 +408,9 @@ describe("generate", () => {
           {
             name: "Time",
             values: ["7am", "8am", "9am"],
-            isPosition: true,
+            noun: "slot",
+            verb: ["is at", "is not at"],
+            ordered: true,
             numericValues: [9, 7, 8],
           },
           { name: "Color", values: ["Red", "Blue", "Green"] },
@@ -494,9 +430,11 @@ 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],
+          },
         },
         {
           name: "Strategy",
@@ -509,7 +447,8 @@ describe("generate", () => {
 
     expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
 
-    // Verify all exact_distance constraints use value-based distances (not positional)
+    // Phase 1: 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 +463,7 @@ describe("generate", () => {
     }
   });
 
-  it("position category gets identity assignment", () => {
+  it("first ordered category gets identity assignment (Phase 1)", () => {
     const puzzle = generate({
       size: 4,
       seed: 42,
@@ -535,10 +474,10 @@ 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"],
+            unit: ["percentage point", "percentage points"] as [string, string],
             comparators: { before: "has a lower return than" },
           },
         },
@@ -551,7 +490,7 @@ describe("generate", () => {
       ],
     });
 
-    // Position category should have identity mapping
+    // First ordered category (Return) gets identity mapping in Phase 1.
     const returnAssignment = puzzle.solution.find((a) => "6%" in a)!;
     expect(returnAssignment["6%"]).toBe(0);
     expect(returnAssignment["7%"]).toBe(1);
@@ -561,7 +500,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 +511,7 @@ describe("generate", () => {
           values: ["9am", "10am", "11am"],
           noun: "slot",
           verb: ["is at", "is not at"],
-          isPosition: true,
+          ordered: true,
         },
         {
           name: "Color",
@@ -583,9 +522,8 @@ 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");
   });
 });
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index e315eaa..b43978d 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -16,8 +16,14 @@ 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 { orderedCategories, resolveAxis } from "./axis";
+import {
+  DEFAULT_CATEGORIES,
+  DEFAULT_SPATIAL_WORDS,
+  DEFAULT_POSITION_NOUN,
+  DEFAULT_POSITION_PREPOSITION,
+  defaultHouseCategory,
+} from "./default-config";
 
 const MAX_RETRIES = 100;
 
@@ -47,40 +53,40 @@ function checkComparators(
 }
 
 /**
- * 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 (c.ordered === true) {
+      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);
     }
-    checkComparators(`Category "${c.name}"`, c.orderingPhrases?.comparators);
-  }
-  if (positionCount > 1) {
-    throw new RangeError("At most one category can have isPosition: true");
   }
 }
 
@@ -177,77 +183,93 @@ 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 posNoun = options?.positionNoun ?? DEFAULT_POSITION_NOUN;
+  const posPrep = options?.positionPreposition ?? DEFAULT_POSITION_PREPOSITION;
+
+  // Derive spatialWords.atPosition from the custom preposition so that
+  // "lives at the 3rd house" etc. flows from a non-default preposition.
+  const spatialWords: typeof DEFAULT_SPATIAL_WORDS = {
+    ...DEFAULT_SPATIAL_WORDS,
+  };
+  if (options?.positionPreposition !== undefined) {
+    spatialWords.atPosition = [
+      `${DEFAULT_SPATIAL_WORDS.verb[0]} ${posPrep}`,
+      `${DEFAULT_SPATIAL_WORDS.verb[1]} ${posPrep}`,
+    ];
+  }
+
   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]}`,
-        ),
+    spatialWords,
+    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 (c.ordered === true) {
+    return {
+      ...base,
+      ordered: true,
+      numericValues: c.numericValues?.slice(0, size),
+      orderingPhrases: c.orderingPhrases,
+      ...withSuffix,
+    } as Category;
+  }
+  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
+  // Phase 1: identity-assign the first ordered category so row = axis rank for
+  // it. This keeps the still-row-based encoder semantically consistent with
+  // the axis-tagged comparatives the generator emits. Phase 2 switches the
+  // encoder to rank-forbidding and removes identity assignment.
+  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 +290,15 @@ 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);
+  // Default axis used for all comparative constraints in Phase 1. Phase 3
+  // will loop over all ordered axes; for now every comparative is tagged
+  // with the first ordered category's name so the existing encoder can
+  // still consume it.
+  const defaultAxis = orderedCategories(grid)[0];
+  /* v8 ignore next 2 */
+  if (!defaultAxis)
+    throw new Error("Grid has no ordered category after buildGrid");
+  const axisName = defaultAxis.name;
 
   // Build indexed arrays for fast access (avoid Map lookups in hot loops)
   const allValues: string[] = [];
@@ -291,8 +320,7 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
   let notSameCount = 0;
   let notNextCount = 0;
 
-  const numVals =
-    posCatIndex >= 0 ? grid.categories[posCatIndex].numericValues : undefined;
+  const numVals = defaultAxis.numericValues;
 
   for (let i = 0; i < allValues.length; i++) {
     const a = allValues[i];
@@ -312,24 +340,24 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
       }
 
       if (Math.abs(posA - posB) === 1) {
-        constraints.push({ type: "next_to", a, b });
+        constraints.push({ type: "next_to", a, b, axis: axisName });
       } else if (posA !== posB && notNextCount < maxPerType) {
-        constraints.push({ type: "not_next_to", a, b });
+        constraints.push({ type: "not_next_to", a, b, axis: axisName });
         notNextCount++;
       }
 
       if (posA === posB - 1) {
-        constraints.push({ type: "left_of", a, b });
+        constraints.push({ type: "left_of", a, b, axis: axisName });
       }
       if (posB === posA - 1) {
-        constraints.push({ type: "left_of", a: b, b: a });
+        constraints.push({ type: "left_of", a: b, b: a, axis: axisName });
       }
 
       // before: a is somewhere left of b (not necessarily adjacent)
       if (posA < posB) {
-        constraints.push({ type: "before", a, b });
+        constraints.push({ type: "before", a, b, axis: axisName });
       } else if (posB < posA) {
-        constraints.push({ type: "before", a: b, b: a });
+        constraints.push({ type: "before", a: b, b: a, axis: axisName });
       }
 
       // exact_distance: emit when meaningful (not redundant with other clue types).
@@ -339,13 +367,25 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
         // 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 });
+          constraints.push({
+            type: "exact_distance",
+            a,
+            b,
+            distance: valDist,
+            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 });
+          constraints.push({
+            type: "exact_distance",
+            a,
+            b,
+            distance: dist,
+            axis: axisName,
+          });
         }
       }
     }
@@ -393,6 +433,7 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
               outer1: v1,
               middle: vals[m],
               outer2: v2,
+              axis: axisName,
             });
           } else {
             constraints.push({
@@ -400,6 +441,7 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
               outer1: v1,
               middle: vals[m],
               outer2: v2,
+              axis: axisName,
             });
           }
           if (++betweenCount >= maxBetween) continue outer;
@@ -408,11 +450,11 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
     }
   }
 
-  // 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 default axis category since their
+  // positions are trivially known via identity assignment.
+  const axisValues = new Set(defaultAxis.values);
   for (const [val, pos] of posOf) {
-    if (posCatValues?.has(val)) continue;
+    if (axisValues.has(val)) continue;
     constraints.push({ type: "at_position", value: val, position: pos });
     for (let p = 0; p < n; p++) {
       if (p !== pos) {
diff --git a/packages/logic-grid/src/grid-utils.test.ts b/packages/logic-grid/src/grid-utils.test.ts
index 6a35d3d..a1c885a 100644
--- a/packages/logic-grid/src/grid-utils.test.ts
+++ b/packages/logic-grid/src/grid-utils.test.ts
@@ -1,88 +1,6 @@
 import { describe, it, expect } from "vitest";
-import {
-  findPositionCategory,
-  positionLabel,
-  posNoun,
-  posNounPlural,
-  posPrep,
-} from "./grid-utils";
+import { posNoun, posNounPlural, posPrep } from "./grid-utils";
 import { makeGrid } from "./test-helpers";
-import { generate } from "./generator";
-
-describe("findPositionCategory", () => {
-  it("returns undefined when no position category", () => {
-    const puzzle = generate({ size: 3, categories: 3, seed: 1 });
-    expect(findPositionCategory(puzzle.grid)).toBeUndefined();
-  });
-
-  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", () => {
diff --git a/packages/logic-grid/src/grid-utils.ts b/packages/logic-grid/src/grid-utils.ts
index 59877db..7b4eeeb 100644
--- a/packages/logic-grid/src/grid-utils.ts
+++ b/packages/logic-grid/src/grid-utils.ts
@@ -1,4 +1,4 @@
-import type { Category, Grid } from "./types";
+import type { Grid } from "./types";
 
 export const ORDINALS = [
   "first",
@@ -32,13 +32,3 @@ export function posPrep(grid: Grid): string {
   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..8151e89 100644
--- a/packages/logic-grid/src/index.ts
+++ b/packages/logic-grid/src/index.ts
@@ -1,5 +1,9 @@
 export { generate } from "./generator";
-export { DEFAULT_CONFIG } from "./default-config";
+export {
+  DEFAULT_CATEGORIES,
+  DEFAULT_SPATIAL_WORDS,
+  defaultHouseCategory,
+} from "./default-config";
 export { solve, hasUniqueSolution } from "./solver";
 export { classify } from "./difficulty";
 export { deduce } from "./deduce";
@@ -19,7 +23,13 @@ export {
 } from "./clues/constraints";
 
 export { renderClue } from "./clues/templates";
-export { findPositionCategory, positionLabel } from "./grid-utils";
+export {
+  resolveAxis,
+  orderedCategories,
+  axisRank,
+  displayAxisCategory,
+  validateConstraints,
+} from "./axis";
 
 export type {
   Category,
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..f3932a3 100644
--- a/packages/logic-grid/src/test-helpers.ts
+++ b/packages/logic-grid/src/test-helpers.ts
@@ -1,10 +1,17 @@
 import type { Category, Grid, SpatialWords } from "./types";
-import { ORDINALS } from "./grid-utils";
-import { DEFAULT_CONFIG } from "./default-config";
+import {
+  DEFAULT_SPATIAL_WORDS,
+  DEFAULT_POSITION_NOUN,
+  DEFAULT_POSITION_PREPOSITION,
+  defaultHouseCategory,
+} from "./default-config";
 
 /**
  * Build a Grid from a minimal description, filling in default rendering fields.
  * 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;
@@ -12,23 +19,21 @@ export function makeGrid(partial: {
   positionNoun?: [string, string];
   positionPreposition?: string;
   spatialWords?: SpatialWords;
-  positionLabels?: string[];
+  displayAxis?: string;
 }): Grid {
-  const positionNoun = partial.positionNoun ?? DEFAULT_CONFIG.positionNoun;
+  const positionNoun = partial.positionNoun ?? DEFAULT_POSITION_NOUN;
   const positionPreposition =
-    partial.positionPreposition ?? DEFAULT_CONFIG.positionPreposition;
-  const positionLabels =
-    partial.positionLabels ??
-    Array.from(
-      { length: partial.size },
-      (_, i) => `the ${ORDINALS[i]} ${positionNoun[0]}`,
-    );
+    partial.positionPreposition ?? DEFAULT_POSITION_PREPOSITION;
+  let categories = partial.categories;
+  if (!categories.some((c) => c.ordered === true)) {
+    categories = [defaultHouseCategory(partial.size), ...categories];
+  }
   return {
     size: partial.size,
-    categories: partial.categories,
+    categories,
     positionNoun,
     positionPreposition,
-    spatialWords: partial.spatialWords ?? DEFAULT_CONFIG.spatialWords,
-    positionLabels,
+    spatialWords: partial.spatialWords ?? { ...DEFAULT_SPATIAL_WORDS },
+    displayAxis: partial.displayAxis,
   };
 }
diff --git a/packages/logic-grid/src/types.ts b/packages/logic-grid/src/types.ts
index da43c34..e27d7e7 100644
--- a/packages/logic-grid/src/types.ts
+++ b/packages/logic-grid/src/types.ts
@@ -39,7 +39,7 @@ export interface SpatialWords {
   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"]`. */
+  /** [positive, negative] for at_position / not_at_position. E.g. `["lives in", "does not live in"]`. */
   atPosition: [string, string];
   /** Spelled-out cardinal numbers for exact_distance. */
   cardinals: string[];
@@ -49,28 +49,62 @@ export interface SpatialWords {
   distanceUnit?: [string, string];
 }
 
-/** 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 phrases for same-position clues: `[positive, negative]`. Required when noun !== "". */
   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.
+ * - `numericValues` and `orderingPhrases` become legal.
+ * - The category participates in multi-axis generation, deduction, rendering.
+ */
+type OrderednessFields =
+  | {
+      ordered: true;
+      /** 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. */
+      orderingPhrases?: OrderingPhrases;
+    }
+  | {
+      ordered?: false;
+      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;
+
 /** The puzzle board: `size` positions and one or more categories. */
 export interface Grid {
   size: number;
@@ -79,10 +113,10 @@ export interface Grid {
   positionNoun: [string, string];
   /** Preposition for positional phrases, e.g. `"in"` → "lives in the first house". */
   positionPreposition: string;
-  /** Configurable words for composing ordering clue sentences. */
+  /** Generic fallback vocabulary 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 +130,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 };
 
@@ -188,4 +241,6 @@ export interface GenerateOptions {
   positionNoun?: [string, string];
   /** Preposition for positional phrases. Default: `"in"`. */
   positionPreposition?: string;
+  /** Optional presentation hint naming an ordered category as display anchor. */
+  displayAxis?: string;
 }

From 5348c5dc61e2427101d20e8a7b8e20d41ed5c73b Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 00:58:38 +0200
Subject: [PATCH 02/24] feat(encoding): rank-forbidding encoder for non-pinned
 ordered axes (phase 2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the 7 comparative encoder cases with a dispatch that uses:
- The cheap positional encoders when the constraint targets the first
  ordered category (which is identity-pinned by encodeBase).
- A shared rank-forbidding encoder for any other ordered axis.

The rank-forbidding encoder works by enumerating forbidden (rank_a, rank_b)
tuples for binary constraints (or (rank_o1, rank_o2, rank_middle) for
between/not_between) and emitting clauses that block each combination over
every compatible (p1, p2[, p3]) position tuple. The 4-literal clauses for
binary and 6-literal clauses for between correctly forbid the combinations
including edge cases where the middle's rank equals an outer's.

Key helpers added:
- badBinaryRankPairs(type, M, distance, numericValues) — enumerates the
  rank-pair combinations that violate each binary comparative type.
- encodeBinaryAxis(ctx, a, b, axis, badPairs) — emits 4-literal clauses.
- encodeBetweenAxis(ctx, o1, m, o2, axis, forbidStrictlyBetween) —
  emits 6-literal clauses. Handles the degenerate case where an outer's
  rank equals the middle's rank (auto-forbidden by construction).
- isIdentityPinnedAxis(grid, axis) — returns true for the first ordered
  category. Used to dispatch to the positional fast path.

The positional fast path is preserved as separate helpers (next_to,
not_next_to, left_of, before, between, not_between, exact_distance) and
delegated to when isIdentityPinnedAxis is true. Phase 4 will remove
identity pinning and switch exclusively to rank-forbidding; until then
the hybrid keeps single-axis puzzles fast while enabling multi-axis
encoding for non-first ordered categories.

Clause counts:
- Positional path (identity-pinned axis): same as before Phase 2, O(n²)
  for between, O(n) for other binaries.
- Rank-forbidding path: O(M²·n²) per binary constraint (≤ 2k clauses
  at M=n=8), O(M³·n³) per between constraint (~100k at M=n=8 — heavy
  but acceptable for small multi-axis puzzles; Phase 4+ can optimize).

Tests: 8 new encoder tests cover each of the 7 comparatives (plus a
numericValues variant) on a non-identity-pinned axis. Constructed via
a multi-axis grid where Year comes first (and is thus identity-pinned)
and Return comes second, forcing the rank-forbidding path for any
constraint referencing "Return".
---
 packages/logic-grid/src/encoding.test.ts | 220 +++++++++
 packages/logic-grid/src/encoding.ts      | 589 ++++++++++++++++-------
 2 files changed, 636 insertions(+), 173 deletions(-)

diff --git a/packages/logic-grid/src/encoding.test.ts b/packages/logic-grid/src/encoding.test.ts
index 282cf66..a63920f 100644
--- a/packages/logic-grid/src/encoding.test.ts
+++ b/packages/logic-grid/src/encoding.test.ts
@@ -332,3 +332,223 @@ describe("encodeConstraint", () => {
     expect(decoded["Water"]).toBe(2);
   });
 });
+
+// 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,
+      },
+      {
+        name: "Return",
+        values: ["5%", "6%", "7%", "8%"],
+        noun: "fund",
+        verb: ["has a return of", "does not have a return of"],
+        ordered: true,
+      },
+    ],
+  });
+  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,
+        },
+        {
+          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],
+        },
+      ],
+    });
+    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 19f5d0a..4c87f71 100644
--- a/packages/logic-grid/src/encoding.ts
+++ b/packages/logic-grid/src/encoding.ts
@@ -1,6 +1,167 @@
-import type { Constraint, Grid } from "./types";
+import type { Category, Constraint, Grid } from "./types";
 import { resolveAxis } from "./axis";
 
+/**
+ * True when `axis` is the first ordered category in `grid`. Phase 1/2 pins
+ * this category by identity in encodeBase, so rank = position for it; we can
+ * use the cheap positional encoders for any comparative constraint targeting
+ * this axis.
+ */
+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.
+ */
+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 {
   grid: Grid;
@@ -94,214 +255,296 @@ export function encodeBase(ctx: EncodingContext): number[][] {
   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;
+}
 
-    case "left_of": {
+/** Encode a single constraint as CNF clauses. */
+export function encodeConstraint(
+  ctx: EncodingContext,
+  constraint: Constraint,
+): number[][] {
+  const n = ctx.numPositions;
+
+  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[][] = [];
+    case "between":
+    case "not_between": {
       const axis = resolveAxis(ctx.grid, constraint.axis);
-      const numVals = axis.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);
-        }
+      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": {

From b1262d2b5aac202ab6e43b49e879c69d076c5e5d Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 10:56:45 +0200
Subject: [PATCH 03/24] feat(generator): multi-axis constraint enumeration
 (phase 3)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Restructure enumerateConstraints to loop over every ordered category and
emit comparative constraints per-axis using rank-space relationships.
Previously the enumerator only emitted comparatives against the first
(identity-pinned) ordered category; now every declared `ordered: true`
category gets its own pass.

For each ordered axis:
- Build a rankAtRow[] map: the row → axis-value-index lookup derived from
  the solution's assignment of that axis category.
- Iterate cross-category value pairs, computing each value's rank on the
  current axis via rankAtRow[solutionPosition(value)]. Emit next_to,
  not_next_to, left_of, before, exact_distance when the rank relationship
  matches.
- Iterate triples for between / not_between similarly.
- Skip any value whose category is the current axis (trivially implied).

Axis-free same_position / not_same_position are enumerated once at the
top (unchanged shape). at_position / not_at_position are still emitted
only for values outside the first ordered category — matching the
encoder's identity-pinning assumption, which Phase 4 will remove.

Notable behaviors:
- Classic single-ordered-category puzzles (auto-House grids, Hedge Fund
  preset) produce byte-equivalent constraints to Phase 2. The outer
  per-axis loop runs once and the inner logic matches the previous
  single-axis enumeration.
- Multi-axis puzzles (two or more `ordered: true` categories) emit
  constraints on each axis. Minimization trims to whichever subset
  yields uniqueness; sweep tests confirm both axes surface in practice.

Test coverage:
- "constraints are consistent with the solution" updated to validate
  comparative constraints in rank space via a rankOf() helper that
  resolves the axis and finds the co-located axis value.
- New "generate with multiple ordered categories" suite:
  - generates a hedge-fund puzzle with Year + Return both ordered,
    confirms hasUniqueSolution and solver round-trip.
  - sweeps 20 seeds to confirm the generator is CAPABLE of emitting
    constraints on each axis (minimization may drop one axis for
    specific seeds; the capability check is what matters).
  - SAT round-trip sanity check on a multi-axis puzzle. Deduction
    completeness is deferred to Phase 4 (rank-space propagation).

The generator still calls classify() which calls deduce() — multi-axis
puzzles that involve non-first-axis constraints may currently stall in
deduce() and get labeled "expert". Phase 4 fixes this.
---
 .../src/__snapshots__/index.test.ts.snap      |  17 +-
 packages/logic-grid/src/generator.test.ts     | 169 ++++++++++--
 packages/logic-grid/src/generator.ts          | 248 ++++++++++--------
 3 files changed, 296 insertions(+), 138 deletions(-)

diff --git a/packages/logic-grid/src/__snapshots__/index.test.ts.snap b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
index b8e28c8..07a4002 100644
--- a/packages/logic-grid/src/__snapshots__/index.test.ts.snap
+++ b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
@@ -2,13 +2,16 @@
 
 exports[`public API integration > generate with custom noun/verb produces correct clues 1`] = `
 [
-  "The tulip grower lives in the second house.",
-  "The italian speaker plays the piano.",
-  "The rose grower lives directly left of the violin player.",
-  "Kai lives somewhere right of the daisy grower.",
-  "The guitar player lives in the second house.",
+  "Kai grows the rose.",
+  "The german speaker plays the violin.",
+  "Luna does not live somewhere between the piano player and the rose grower.",
+  "The german speaker lives next to the drums player.",
+  "Theo lives next to the guitar player.",
+  "The lily grower plays the violin.",
+  "The third house grows the rose.",
+  "The first house does not grow the tulip.",
+  "The piano player lives in the first house.",
+  "The first house speaks italian.",
   "The french speaker lives in the third house.",
-  "Nora speaks spanish.",
-  "Luna lives exactly three houses from the first house.",
 ]
 `;
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index 4b7b045..fb4ab06 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -2,6 +2,8 @@ import { describe, it, expect } from "vitest";
 import { generate } from "./generator";
 import { deduce } from "./deduce";
 import { hasUniqueSolution, solve } from "./solver";
+import { resolveAxis } from "./axis";
+import type { Grid } from "./types";
 
 describe("generate", () => {
   it("returns a valid puzzle with defaults", () => {
@@ -38,6 +40,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 +58,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,19 +92,34 @@ 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;
+        }
       }
     }
   });
@@ -527,3 +566,97 @@ describe("generate", () => {
     expect(orderedCat!.name).toBe("Time");
   });
 });
+
+describe("generate with multiple ordered categories", () => {
+  const hedgeFundCategories = [
+    {
+      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,
+    },
+    {
+      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,
+    },
+    {
+      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", () => {
+    // Phase 3 only guarantees SAT-level uniqueness. Phase 4 adds rank-space
+    // deduction for non-first ordered axes; until then `deduce()` may stall
+    // on constraints targeting a non-pinned axis. The solver, however, must
+    // reproduce the exact solution.
+    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);
+      }
+    }
+  });
+});
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index b43978d..4a1d2f0 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -290,15 +290,10 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
   const constraints: Constraint[] = [];
   const n = grid.size;
 
-  // Default axis used for all comparative constraints in Phase 1. Phase 3
-  // will loop over all ordered axes; for now every comparative is tagged
-  // with the first ordered category's name so the existing encoder can
-  // still consume it.
-  const defaultAxis = orderedCategories(grid)[0];
+  const orderedCats = orderedCategories(grid);
   /* v8 ignore next 2 */
-  if (!defaultAxis)
+  if (orderedCats.length === 0)
     throw new Error("Grid has no ordered category after buildGrid");
-  const axisName = defaultAxis.name;
 
   // Build indexed arrays for fast access (avoid Map lookups in hot loops)
   const allValues: string[] = [];
@@ -311,150 +306,177 @@ 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 = defaultAxis.numericValues;
 
   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, axis: axisName });
-      } else if (posA !== posB && notNextCount < maxPerType) {
-        constraints.push({ type: "not_next_to", a, b, axis: axisName });
-        notNextCount++;
-      }
-
-      if (posA === posB - 1) {
-        constraints.push({ type: "left_of", a, b, axis: axisName });
-      }
-      if (posB === posA - 1) {
-        constraints.push({ type: "left_of", a: b, b: a, axis: axisName });
-      }
-
-      // before: a is somewhere left of b (not necessarily adjacent)
-      if (posA < posB) {
-        constraints.push({ type: "before", a, b, axis: axisName });
-      } else if (posB < posA) {
-        constraints.push({ type: "before", a: b, b: a, axis: axisName });
-      }
+  // --- 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 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) {
+          constraints.push({ type: "next_to", a, b, axis: axisName });
+        } 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,
-            axis: axisName,
-          });
+        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,
-            axis: axisName,
-          });
+        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 values in the default axis category since their
-  // positions are trivially known via identity assignment.
-  const axisValues = new Set(defaultAxis.values);
+  // --- Position constraints ---
+  // Skip values in the first ordered category — identity pinning makes their
+  // rows trivially determined by encodeBase. Phase 4 removes identity pinning
+  // and broadens this skip rule.
+  const firstOrdered = orderedCats[0];
+  const firstOrderedValues = new Set(firstOrdered.values);
   for (const [val, pos] of posOf) {
-    if (axisValues.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) {

From ff4adeff59322d660cb703e2fde7c7b3580520a7 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 11:13:30 +0200
Subject: [PATCH 04/24] feat(deduce): rank-space propagation for non-pinned
 ordered axes (phase 4)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add rank-space deduction helpers and update all 7 comparative try*
functions to dispatch through them when the constraint's axis is not
identity-pinned (i.e. not the first ordered category).

New helpers in deduce/state.ts:
- axisRankDomain(state, value, axis): computes the set of ranks `value`
  could occupy on `axis` by checking which axis values share a possible
  position with the value.
- projectRanksToPositions(state, value, axis, eliminatedRanks): projects
  rank eliminations back to position eliminations — a position is
  eliminated if its only possible axis value has an eliminated rank.

New helper in deduce/constraints.ts:
- tryBinaryRankSpace(): generic rank-space deduction for binary
  comparatives (before, left_of, next_to, not_next_to, exact_distance).
  Takes a predicate `isValid(rankA, rankB)` and eliminates ranks that
  have no valid partner. Projects back via projectRanksToPositions.
- tryBetweenRankSpace(): rank-space deduction for between/not_between
  on ternary constraints. Eliminates ranks for middle and outers that
  can't participate in any valid rank triple.
- isIdentityPinned(): returns true for the first ordered category.
  Used to dispatch to the existing positional fast path when applicable.

Each try* function dispatches:
- Identity-pinned axis → existing positional logic (unchanged behavior,
  equivalent to pre-Phase-4).
- Non-pinned axis → rank-space path via tryBinaryRankSpace or
  tryBetweenRankSpace.

The rank-space propagation is correct but weaker than full positional
propagation in corner cases — it projects through axisRankDomain which
loses joint-possibility information. The existing SAT-based contradiction
fallback (deduce/contradiction.ts) closes any propagation gaps, exactly
as it does for positional constraints today.

Tests: new "rank-space deduction on non-pinned axis" suite exercises
the rank-space path directly via tryConstraint with a pre-configured
state, confirming that before(Alice, Bob, Return) correctly eliminates
Alice's position when her only possible Return rank is the maximum.
---
 .../logic-grid/src/deduce/constraints.test.ts |  79 +++++
 packages/logic-grid/src/deduce/constraints.ts | 274 +++++++++++++++++-
 packages/logic-grid/src/deduce/state.ts       |  62 +++-
 3 files changed, 403 insertions(+), 12 deletions(-)

diff --git a/packages/logic-grid/src/deduce/constraints.test.ts b/packages/logic-grid/src/deduce/constraints.test.ts
index ef33673..2b66a95 100644
--- a/packages/logic-grid/src/deduce/constraints.test.ts
+++ b/packages/logic-grid/src/deduce/constraints.test.ts
@@ -932,3 +932,82 @@ 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,
+      },
+      {
+        name: "Return",
+        values: ["5%", "6%", "7%", "8%"],
+        noun: "fund",
+        verb: ["has a return of", "does not have a return of"],
+        ordered: true,
+      },
+    ],
+  });
+
+  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,
+    });
+  });
+});
diff --git a/packages/logic-grid/src/deduce/constraints.ts b/packages/logic-grid/src/deduce/constraints.ts
index f007622..bd540ac 100644
--- a/packages/logic-grid/src/deduce/constraints.ts
+++ b/packages/logic-grid/src/deduce/constraints.ts
@@ -1,4 +1,9 @@
-import type { Constraint, DeductionStep, DeductionTechnique } from "../types";
+import type {
+  Category,
+  Constraint,
+  DeductionStep,
+  DeductionTechnique,
+} from "../types";
 import { ordinal, posNoun, posNounPlural, posPrep } from "../grid-utils";
 import { resolveAxis } from "../axis";
 import {
@@ -13,6 +18,8 @@ import {
   describeResult,
   clueRef,
   describeKnown,
+  axisRankDomain,
+  projectRanksToPositions,
 } from "./state";
 
 /** Check whether every position in `set` is adjacent to `p`. */
@@ -23,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(
@@ -192,17 +271,43 @@ function tryNotSamePosition(
 
 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);
 }
 
@@ -287,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 });
   }
@@ -323,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) {
@@ -361,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);
@@ -474,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);
@@ -547,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; 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 = resolveAxis(state.grid, c.axis).numericValues;
+  const numVals = axis.numericValues;
 
   if (numVals) {
     // Value-based distance: compute valid partner positions from numeric values
diff --git a/packages/logic-grid/src/deduce/state.ts b/packages/logic-grid/src/deduce/state.ts
index f61a688..145be92 100644
--- a/packages/logic-grid/src/deduce/state.ts
+++ b/packages/logic-grid/src/deduce/state.ts
@@ -1,4 +1,9 @@
-import type { Grid, DeductionStep, DeductionTechnique } from "../types";
+import type {
+  Category,
+  Grid,
+  DeductionStep,
+  DeductionTechnique,
+} from "../types";
 import { ordinal, posNoun, posPrep } from "../grid-utils";
 
 // --- Display utilities ---
@@ -170,3 +175,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;
+}

From fdde9022627ad8bb9d868dc53a2cd8d8228d3b60 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 11:35:19 +0200
Subject: [PATCH 05/24] feat(rendering): per-axis comparator and unit lookup
 (phase 5)

Thread the constraint's axis through the comparator and unit lookup in
templates.ts. Each comparative constraint now checks the axis category's
orderingPhrases.comparators first, falling back to grid-level
spatialWords.comparators, then to default spatial-word composition.
exact_distance additionally checks axis.orderingPhrases.unit before
grid.spatialWords.distanceUnit before grid.positionNoun.

This means a multi-axis puzzle where Year has
  orderingPhrases.comparators.before = ["was begun earlier than", ...]
and Return has
  orderingPhrases.comparators.before = ["has a lower return than", ...]
will render clues on each axis using the correct domain-specific phrasing
without cross-contamination.

Tests: new "per-axis orderingPhrases in rendering" suite verifies:
- before uses Year comparators when axis=Year, Return when axis=Return
- next_to uses Year comparator when axis=Year, falls through to grid
  default when axis=Return (which has no next_to override)
- exact_distance uses per-axis unit for Return, grid default for Year

327 tests passing across all 3 workspaces.
---
 .../logic-grid/src/clues/templates.test.ts    | 109 ++++++++++++++++++
 packages/logic-grid/src/clues/templates.ts    |  55 +++++++--
 2 files changed, 154 insertions(+), 10 deletions(-)

diff --git a/packages/logic-grid/src/clues/templates.test.ts b/packages/logic-grid/src/clues/templates.test.ts
index 7aabacf..0352b9a 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -426,6 +426,115 @@ describe("distance unit from spatialWords.distanceUnit", () => {
   });
 });
 
+describe("per-axis orderingPhrases in rendering", () => {
+  // Grid with two ordered axes, each with its own comparator phrases.
+  const multiGrid = makeGrid({
+    size: 3,
+    categories: [
+      {
+        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,
+            ],
+            next_to: "was begun in the closest year to",
+          },
+        },
+      },
+      {
+        name: "Return",
+        values: ["5%", "6%", "7%"],
+        noun: "fund",
+        verb: ["has a return of", "does not have a return of"],
+        ordered: true,
+        orderingPhrases: {
+          unit: ["percentage point", "percentage points"] as [string, string],
+          comparators: {
+            before: ["has a lower return than", "has a higher return than"] as [
+              string,
+              string,
+            ],
+          },
+        },
+      },
+    ],
+  });
+
+  it("before uses Year axis comparators when axis=Year", () => {
+    const clue = renderClue(
+      { type: "before", a: "Alice", b: "Bob", axis: "Year" },
+      multiGrid,
+    );
+    expect(clue.text).toMatch(/was begun (earlier|later) than/);
+  });
+
+  it("before uses Return axis comparators when axis=Return", () => {
+    const clue = renderClue(
+      { type: "before", a: "Alice", b: "Bob", axis: "Return" },
+      multiGrid,
+    );
+    expect(clue.text).toMatch(/has a (lower|higher) return than/);
+  });
+
+  it("next_to uses Year axis comparators when axis=Year", () => {
+    const clue = renderClue(
+      { type: "next_to", a: "Alice", b: "Bob", axis: "Year" },
+      multiGrid,
+    );
+    expect(clue.text).toContain("was begun in the closest year to");
+  });
+
+  it("next_to falls through to grid defaults when axis=Return (no next_to override)", () => {
+    const clue = renderClue(
+      { type: "next_to", a: "Alice", b: "Bob", axis: "Return" },
+      multiGrid,
+    );
+    // Return has no next_to comparator → falls through to spatial words default.
+    expect(clue.text).toMatch(/lives next to/);
+  });
+
+  it("exact_distance uses per-axis unit when axis has one", () => {
+    const clue = renderClue(
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Return",
+      },
+      multiGrid,
+    );
+    expect(clue.text).toContain("2 percentage points");
+  });
+
+  it("exact_distance uses grid default when axis has no unit", () => {
+    const clue = renderClue(
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "Year",
+      },
+      multiGrid,
+    );
+    // Year has no unit → falls through to cardinals ("two houses").
+    expect(clue.text).toContain("two houses");
+  });
+});
+
 describe("default spatial words sanity", () => {
   it("DEFAULT_SPATIAL_WORDS has expected shape", () => {
     const w: SpatialWords = DEFAULT_SPATIAL_WORDS;
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index e0652c3..d69694a 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -29,10 +29,22 @@ function objectValue(value: string, grid: Grid): string {
   return suffix ? `${value.toLowerCase()} ${suffix}` : value.toLowerCase();
 }
 
+/**
+ * Look up a comparator phrase. Checks the axis category's orderingPhrases
+ * first, then falls back to grid-level spatialWords.comparators.
+ */
 function comparator(
   grid: Grid,
   type: OrderingComparatorType,
+  axisName?: string,
 ): string | [string, string] | undefined {
+  if (axisName) {
+    const axis = grid.categories.find((c) => c.name === axisName);
+    if (axis?.ordered === true) {
+      const phrase = axis.orderingPhrases?.comparators?.[type];
+      if (phrase !== undefined) return phrase;
+    }
+  }
   return grid.spatialWords.comparators?.[type];
 }
 
@@ -43,8 +55,9 @@ function comparator(
 function symmetricComp(
   grid: Grid,
   type: OrderingComparatorType,
+  axisName?: string,
 ): string | undefined {
-  return comparator(grid, type) as string | undefined;
+  return comparator(grid, type, axisName) as string | undefined;
 }
 
 /**
@@ -58,8 +71,9 @@ function directionalComp(
   type: OrderingComparatorType,
   a: string,
   b: string,
+  axisName?: string,
 ): { subject: string; object: string; phrase: string } | undefined {
-  const c = comparator(grid, type);
+  const c = comparator(grid, type, axisName);
   if (c === undefined) return undefined;
   if (typeof c === "string") {
     return { subject: a, object: b, phrase: c };
@@ -139,16 +153,22 @@ 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");
+      const comp = symmetricComp(grid, "next_to", constraint.axis);
       return `${capitalize(label(s, grid))} ${comp ?? `${w.verb[0]} ${w.adjacency}`} ${label(o, grid)}.`;
     }
     case "not_next_to": {
       const [s, o] = ordered(constraint.a, constraint.b, grid);
-      const comp = symmetricComp(grid, "not_next_to");
+      const comp = symmetricComp(grid, "not_next_to", constraint.axis);
       return `${capitalize(label(s, grid))} ${comp ?? `${w.verb[1]} ${w.adjacency}`} ${label(o, grid)}.`;
     }
     case "left_of": {
-      const comp = directionalComp(grid, "left_of", constraint.a, constraint.b);
+      const comp = directionalComp(
+        grid,
+        "left_of",
+        constraint.a,
+        constraint.b,
+        constraint.axis,
+      );
       if (comp) {
         return `${capitalize(label(comp.subject, grid))} ${comp.phrase} ${label(comp.object, grid)}.`;
       }
@@ -160,7 +180,7 @@ function renderText(constraint: Constraint, grid: Grid): string {
       const lm = label(constraint.middle, grid);
       const lo1 = label(constraint.outer1, grid);
       const lo2 = label(constraint.outer2, grid);
-      const comp = symmetricComp(grid, "between");
+      const comp = symmetricComp(grid, "between", constraint.axis);
       if (comp) return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
       const middleVerb =
         findCategory(constraint.middle, grid).positionAdjective?.[0] ??
@@ -171,7 +191,7 @@ function renderText(constraint: Constraint, grid: Grid): string {
       const lm = label(constraint.middle, grid);
       const lo1 = label(constraint.outer1, grid);
       const lo2 = label(constraint.outer2, grid);
-      const comp = symmetricComp(grid, "not_between");
+      const comp = symmetricComp(grid, "not_between", constraint.axis);
       if (comp) return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
       const middleVerb =
         findCategory(constraint.middle, grid).positionAdjective?.[1] ??
@@ -179,7 +199,13 @@ function renderText(constraint: Constraint, grid: Grid): string {
       return `${capitalize(lm)} ${middleVerb} ${w.between} ${lo1} and ${lo2}.`;
     }
     case "before": {
-      const comp = directionalComp(grid, "before", constraint.a, constraint.b);
+      const comp = directionalComp(
+        grid,
+        "before",
+        constraint.a,
+        constraint.b,
+        constraint.axis,
+      );
       if (comp) {
         return `${capitalize(label(comp.subject, grid))} ${comp.phrase} ${label(comp.object, grid)}.`;
       }
@@ -191,9 +217,18 @@ function renderText(constraint: Constraint, grid: Grid): string {
       const [s, o] = ordered(constraint.a, constraint.b, grid);
       const la = label(s, grid);
       const lb = label(o, grid);
-      const unit = w.distanceUnit;
+      // Per-axis unit takes precedence over grid-level distanceUnit.
+      const axisCategory = grid.categories.find(
+        (c) => c.name === constraint.axis,
+      );
+      const axisUnit =
+        axisCategory?.ordered === true
+          ? axisCategory.orderingPhrases?.unit
+          : undefined;
+      const unit = axisUnit ?? w.distanceUnit;
       const prefix =
-        symmetricComp(grid, "exact_distance") ?? `${w.verb[0]} exactly`;
+        symmetricComp(grid, "exact_distance", constraint.axis) ??
+        `${w.verb[0]} exactly`;
       if (unit) {
         const unitNoun = constraint.distance === 1 ? unit[0] : unit[1];
         return `${capitalize(la)} ${prefix} ${constraint.distance} ${unitNoun} from ${lb}.`;

From 54adf01a734b79f17e75dbde12f461b3446b7dd6 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 12:43:23 +0200
Subject: [PATCH 06/24] fix: at_position rendering, rank-vs-value phrasing,
 multi-axis preset

Fix at_position rendering to use the first ordered category's verb
instead of generic spatialWords.atPosition. The value is always subject
and the axis value is always object, preventing wrong verb assignment.
Remove now-unused positionLabel helper.

Fix rank-adjacency comparator phrasing across all demo presets and the
AI prompt example. next_to and left_of mean "adjacent in rank order"
(no other value between them), NOT "close in value" or "exactly 1 unit
apart". With non-equidistant numericValues, rank-adjacent values can
have different gaps, so phrasing must not imply specific value distances.

Phrasing rules applied:
- next_to: "right before or after" (temporal), "right above or below"
  (numeric scales). Never "closest", "nearest", "adjacent to", "within
  N units of".
- left_of: "right before" / "right after", "the next higher/lower".
  Never "exactly one X before/after".
- exact_distance: the only constraint that may claim specific value
  gaps, via numericValues + unit.

Add AI prompt guidance explaining the rank-vs-value distinction so
AI-generated themes avoid the same fallacy.

Add "Hedge Funds (Multi-Axis)" demo preset with Year and Return both
ordered, numericValues on Year for value-based exact_distance, and
complete comparator phrase sets using correct rank-order phrasing.
---
 packages/demo/src/routes/+page.svelte      | 63 +++++++++++++++++++---
 packages/logic-grid-ai/src/theme.ts        |  4 +-
 packages/logic-grid/src/clues/templates.ts | 54 +++++++++++--------
 3 files changed, 91 insertions(+), 30 deletions(-)

diff --git a/packages/demo/src/routes/+page.svelte b/packages/demo/src/routes/+page.svelte
index 7912237..a723b21 100644
--- a/packages/demo/src/routes/+page.svelte
+++ b/packages/demo/src/routes/+page.svelte
@@ -36,8 +36,8 @@
                 "has the next lower return than",
                 "has the next higher return than",
               ] as [string, string],
-              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",
@@ -71,11 +71,11 @@
                 "has a later appointment than",
               ] as [string, string],
               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",
               ] as [string, string],
-              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",
@@ -88,6 +88,57 @@
       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"] as [string, string],
+            comparators: {
+              before: ["started earlier than", "started later than"] as [string, string],
+              left_of: ["started right before", "started right after"] as [string, string],
+              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"] as [string, string],
+            comparators: {
+              before: ["has a lower return than", "has a higher return than"] as [string, string],
+              left_of: ["has the next lower return than", "has the next higher return than"] 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: "Fund", values: ["Black River", "Citizen Trust", "Pine Bay", "Silver Rock"], noun: "fund", subjectPriority: 1, verb: ["runs", "does not run"], valueSuffix: "fund" },
+      ],
+      positionNoun: ["fund", "funds"],
+      positionPreposition: "at",
+    },
   };
 
   let size = $state(4);
diff --git a/packages/logic-grid-ai/src/theme.ts b/packages/logic-grid-ai/src/theme.ts
index 20bdc8a..73335c0 100644
--- a/packages/logic-grid-ai/src/theme.ts
+++ b/packages/logic-grid-ai/src/theme.ts
@@ -157,6 +157,8 @@ At least one category must have \`ordered: true\` so comparative constraints can
 - 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"]\`.
 
+**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", "the next higher/lower". Only \`exact_distance\` may claim specific value gaps (it uses numericValues to compute the actual difference).
+
 ## Examples
 
 ### Classic puzzle with a position-adjective category (Color)
@@ -179,7 +181,7 @@ 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"], "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 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 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": "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"] }
   ],
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index d69694a..69e79b8 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -239,37 +239,45 @@ function renderText(constraint: Constraint, grid: Grid): string {
       return `${capitalize(la)} ${prefix} ${dist} ${noun} from ${lb}.`;
     }
     case "at_position": {
-      const posLabel = positionLabel(grid, constraint.position);
-      const cat = findCategory(constraint.value, grid);
-      if (cat.positionAdjective) {
-        return `${capitalize(posLabel)} ${cat.positionAdjective[0]} ${constraint.value.toLowerCase()}.`;
+      // Render using the first ordered category's value at this position.
+      // The ordered value is always the object (position-like) side: we use
+      // its verb to produce "Alice lives in the first house" (House's verb),
+      // not "The first house plays piano" (Instrument's verb).
+      const axis = orderedCategories(grid)[0];
+      if (axis) {
+        const axisVal = axis.values[constraint.position];
+        const cat = findCategory(constraint.value, grid);
+        const idx = 0;
+        // positionAdjective path: "The first house is red."
+        if (cat.positionAdjective) {
+          return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[idx]} ${constraint.value.toLowerCase()}.`;
+        }
+        const verb = axis.verb;
+        if (verb) {
+          return `${capitalize(label(constraint.value, grid))} ${verb[idx]} ${objectValue(axisVal, grid)}.`;
+        }
       }
-      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[0]} ${posLabel}.`;
+      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[0]} position ${constraint.position + 1}.`;
     }
     case "not_at_position": {
-      const posLabel = positionLabel(grid, constraint.position);
-      const cat = findCategory(constraint.value, grid);
-      if (cat.positionAdjective) {
-        return `${capitalize(posLabel)} ${cat.positionAdjective[1]} ${constraint.value.toLowerCase()}.`;
+      const axis = orderedCategories(grid)[0];
+      if (axis) {
+        const axisVal = axis.values[constraint.position];
+        const cat = findCategory(constraint.value, grid);
+        const idx = 1;
+        if (cat.positionAdjective) {
+          return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[idx]} ${constraint.value.toLowerCase()}.`;
+        }
+        const verb = axis.verb;
+        if (verb) {
+          return `${capitalize(label(constraint.value, grid))} ${verb[idx]} ${objectValue(axisVal, grid)}.`;
+        }
       }
-      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[1]} ${posLabel}.`;
+      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[1]} position ${constraint.position + 1}.`;
     }
   }
 }
 
-/**
- * Derive a human-readable label for row `position`. Reads from the first
- * ordered category's value at that index (identity-assigned in Phase 1).
- * Falls back to a generic "the Nth <positionNoun>" phrasing.
- */
-function positionLabel(grid: Grid, position: number): string {
-  const axis = orderedCategories(grid)[0];
-  if (axis) {
-    return label(axis.values[position], grid);
-  }
-  return `the ${capitalize(posNoun(grid))} at position ${position + 1}`;
-}
-
 function capitalize(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }

From fa18b2f322b0ad8cb4f82f4a190dd87ee4c80373 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 12:53:45 +0200
Subject: [PATCH 07/24] fix(demo): nudge skips steps whose eliminations are
 already applied

findNextStep treated confirmed cells in the elimination list as pending
work, so nudge kept pointing at a clue after the user correctly filled
it in. Now only empty cells count as unapplied eliminations.
---
 packages/demo/src/lib/puzzle-state.svelte.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/demo/src/lib/puzzle-state.svelte.ts b/packages/demo/src/lib/puzzle-state.svelte.ts
index 8587b10..5ca6146 100644
--- a/packages/demo/src/lib/puzzle-state.svelte.ts
+++ b/packages/demo/src/lib/puzzle-state.svelte.ts
@@ -429,7 +429,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";

From 65637b3540db42f0b47f5b18ab9db7ff3f9ab676 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 13:18:17 +0200
Subject: [PATCH 08/24] docs: update README for multi-axis ordered categories

Update constraint factory signatures (axis parameter), rename
same_house to same_position throughout, add multi-axis example with
Year and Return both ordered, document orderingPhrases/numericValues,
update types section and constraint types table.
---
 packages/logic-grid/README.md | 163 +++++++++++++++++++++++-----------
 1 file changed, 112 insertions(+), 51 deletions(-)

diff --git a/packages/logic-grid/README.md b/packages/logic-grid/README.md
index 1c34d2d..4361f52 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,24 @@ type Difficulty = "easy" | "medium" | "hard" | "expert";
 interface Grid {
   size: number;
   categories: Category[];
+  positionNoun: [string, string];
+  positionPreposition: string;
+  spatialWords: SpatialWords;
+  displayAxis?: string;
 }
 
-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 enables numericValues and orderingPhrases.
+// valueSuffix enables positionAdjective.
 
 type Solution = Assignment[]; // one per category
 type Assignment = Record<string, number>; // value → position (0-indexed)
@@ -229,11 +290,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.
 

From 1b59d7a0b42fec83832878327ea9dc35af83cabc Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 13:56:31 +0200
Subject: [PATCH 09/24] test: restore 100% coverage across all packages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add axis.ts unit tests, factory tests for atPosition/notAtPosition,
generator validation tests (duplicate names, numericValues length,
invalid displayAxis), and rank-space deduction tests for left_of,
between, not_between, exact_distance (with and without numericValues)
on non-pinned axes.

Replace defensive silent fallbacks with throws in encoding.ts,
templates.ts, and deduce/state.ts — missing ordered category now
surfaces immediately instead of producing wrong output.

Simplify templates.ts comparator/unit lookup: use resolveAxis instead
of redundant find + ordered check, eliminating unreachable branches.
Make comparator helper params required (axis is always provided).

Add AI validation test for missing ordered category.

Coverage: 100% statements, branches, functions, lines in both
logic-grid and logic-grid-ai.
---
 packages/logic-grid-ai/src/validation.test.ts |  10 +
 packages/logic-grid/src/axis.test.ts          | 138 ++++++++++++
 .../logic-grid/src/clues/constraints.test.ts  |  18 ++
 .../logic-grid/src/clues/templates.test.ts    | 132 ++++++++++++
 packages/logic-grid/src/clues/templates.ts    |  70 +++---
 .../logic-grid/src/deduce/constraints.test.ts | 203 ++++++++++++++++++
 packages/logic-grid/src/deduce/state.test.ts  |  16 ++
 packages/logic-grid/src/deduce/state.ts       |  15 +-
 packages/logic-grid/src/encoding.test.ts      |  20 +-
 packages/logic-grid/src/encoding.ts           |  12 +-
 packages/logic-grid/src/generator.test.ts     |  73 +++++++
 11 files changed, 646 insertions(+), 61 deletions(-)
 create mode 100644 packages/logic-grid/src/axis.test.ts

diff --git a/packages/logic-grid-ai/src/validation.test.ts b/packages/logic-grid-ai/src/validation.test.ts
index 0c97de8..bfa8e94 100644
--- a/packages/logic-grid-ai/src/validation.test.ts
+++ b/packages/logic-grid-ai/src/validation.test.ts
@@ -234,6 +234,16 @@ describe("validateThemeResult", () => {
     expect(validateThemeResult(r, 3, 3)).toEqual([]);
   });
 
+  it("rejects when no category is ordered", () => {
+    const r = validResult();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+    delete (r.categories[1] as any).ordered;
+    const errors = validateThemeResult(r, 3, 3);
+    expect(errors).toContainEqual(
+      expect.stringContaining("No ordered category found"),
+    );
+  });
+
   it("accepts multiple ordered categories", () => {
     const r = validResult();
     r.categories[2].ordered = true;
diff --git a/packages/logic-grid/src/axis.test.ts b/packages/logic-grid/src/axis.test.ts
new file mode 100644
index 0000000..7fd3961
--- /dev/null
+++ b/packages/logic-grid/src/axis.test.ts
@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import {
+  orderedCategories,
+  resolveAxis,
+  axisRank,
+  displayAxisCategory,
+  validateConstraints,
+} from "./axis";
+import { makeGrid } 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,
+    },
+    {
+      name: "Return",
+      values: ["5%", "6%", "7%"],
+      noun: "fund",
+      verb: ["has a return of", "does not have a return of"],
+      ordered: true,
+    },
+  ],
+});
+
+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/clues/constraints.test.ts b/packages/logic-grid/src/clues/constraints.test.ts
index 0c4810f..57640f8 100644
--- a/packages/logic-grid/src/clues/constraints.test.ts
+++ b/packages/logic-grid/src/clues/constraints.test.ts
@@ -9,6 +9,8 @@ import {
   notBetween,
   before,
   exactDistance,
+  atPosition,
+  notAtPosition,
 } from "./constraints";
 
 describe("constraint factories", () => {
@@ -93,4 +95,20 @@ describe("constraint factories", () => {
       axis: "House",
     });
   });
+
+  it("atPosition", () => {
+    expect(atPosition("Red", 0)).toEqual({
+      type: "at_position",
+      value: "Red",
+      position: 0,
+    });
+  });
+
+  it("notAtPosition", () => {
+    expect(notAtPosition("Red", 2)).toEqual({
+      type: "not_at_position",
+      value: "Red",
+      position: 2,
+    });
+  });
 });
diff --git a/packages/logic-grid/src/clues/templates.test.ts b/packages/logic-grid/src/clues/templates.test.ts
index 0352b9a..ebd25bd 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -323,6 +323,14 @@ describe("grid-level comparator overrides", () => {
     },
   };
 
+  it("left_of uses grid comparator when set", () => {
+    const clue = renderClue(
+      { type: "left_of", a: "Alice", b: "Bob", axis: "House" },
+      withComparators,
+    );
+    expect(clue.text).toBe("Alice is directly before Bob.");
+  });
+
   it("before uses grid comparator when set", () => {
     const clue = renderClue(
       { type: "before", a: "Alice", b: "Bob", axis: "House" },
@@ -341,6 +349,34 @@ describe("grid-level comparator overrides", () => {
     );
   });
 
+  it("not_between uses grid comparator when set", () => {
+    const clue = renderClue(
+      {
+        type: "not_between",
+        outer1: "Alice",
+        middle: "Bob",
+        outer2: "Carol",
+        axis: "House",
+      },
+      withComparators,
+    );
+    expect(clue.text).toBe("Bob is not between Alice and Carol.");
+  });
+
+  it("exact_distance uses grid comparator when set", () => {
+    const clue = renderClue(
+      {
+        type: "exact_distance",
+        a: "Alice",
+        b: "Bob",
+        distance: 2,
+        axis: "House",
+      },
+      withComparators,
+    );
+    expect(clue.text).toContain("is exactly");
+  });
+
   it("between uses grid comparator when set", () => {
     const clue = renderClue(
       {
@@ -426,6 +462,36 @@ describe("distance unit from spatialWords.distanceUnit", () => {
   });
 });
 
+describe("left_of with tuple comparator picks forward or reverse", () => {
+  const withTupleLeftOf: Grid = {
+    ...grid,
+    spatialWords: {
+      ...grid.spatialWords,
+      comparators: {
+        left_of: ["is right before", "is right after"] as [string, string],
+      },
+    },
+  };
+
+  it("picks reverse phrasing when hash tiebreaker selects b as subject", () => {
+    // simpleHash("Alice"+"Bob") % 2 === 1 → reverse: Bob is subject
+    const clue = renderClue(
+      { type: "left_of", a: "Alice", b: "Bob", axis: "House" },
+      withTupleLeftOf,
+    );
+    expect(clue.text).toBe("Bob is right after Alice.");
+  });
+
+  it("picks forward phrasing when hash tiebreaker selects a as subject", () => {
+    // simpleHash("Bob"+"Carol") % 2 === 0 → forward: Bob is subject
+    const clue = renderClue(
+      { type: "left_of", a: "Bob", b: "Carol", axis: "House" },
+      withTupleLeftOf,
+    );
+    expect(clue.text).toBe("Bob is right before Carol.");
+  });
+});
+
 describe("per-axis orderingPhrases in rendering", () => {
   // Grid with two ordered axes, each with its own comparator phrases.
   const multiGrid = makeGrid({
@@ -535,6 +601,72 @@ describe("per-axis orderingPhrases in rendering", () => {
   });
 });
 
+describe("at_position / not_at_position invariants", () => {
+  const bareGrid: Grid = {
+    size: 3,
+    categories: [{ name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" }],
+    positionNoun: ["house", "houses"],
+    positionPreposition: "in",
+    spatialWords: DEFAULT_SPATIAL_WORDS,
+  };
+
+  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_at_position throws when grid has no ordered category", () => {
+    expect(() =>
+      renderClue(
+        { type: "not_at_position", value: "Alice", position: 0 },
+        bareGrid,
+      ),
+    ).toThrow("no ordered category");
+  });
+
+  it("at_position throws when ordered category has no verb", () => {
+    const noVerbGrid: Grid = {
+      size: 3,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+        { name: "Axis", values: ["X", "Y", "Z"], ordered: true },
+      ],
+      positionNoun: ["house", "houses"],
+      positionPreposition: "in",
+      spatialWords: DEFAULT_SPATIAL_WORDS,
+    };
+    expect(() =>
+      renderClue(
+        { type: "at_position", value: "Alice", position: 0 },
+        noVerbGrid,
+      ),
+    ).toThrow("has no verb");
+  });
+
+  it("not_at_position throws when ordered category has no verb", () => {
+    const noVerbGrid: Grid = {
+      size: 3,
+      categories: [
+        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+        { name: "Axis", values: ["X", "Y", "Z"], ordered: true },
+      ],
+      positionNoun: ["house", "houses"],
+      positionPreposition: "in",
+      spatialWords: DEFAULT_SPATIAL_WORDS,
+    };
+    expect(() =>
+      renderClue(
+        { type: "not_at_position", value: "Alice", position: 0 },
+        noVerbGrid,
+      ),
+    ).toThrow("has no verb");
+  });
+});
+
 describe("default spatial words sanity", () => {
   it("DEFAULT_SPATIAL_WORDS has expected shape", () => {
     const w: SpatialWords = DEFAULT_SPATIAL_WORDS;
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 69e79b8..3d6099a 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -6,7 +6,7 @@ import type {
   OrderingComparatorType,
 } from "../types";
 import { posNoun, posNounPlural } from "../grid-utils";
-import { orderedCategories } from "../axis";
+import { orderedCategories, resolveAxis } from "../axis";
 
 function findCategory(value: string, grid: Grid): Category {
   for (const cat of grid.categories) {
@@ -36,16 +36,11 @@ function objectValue(value: string, grid: Grid): string {
 function comparator(
   grid: Grid,
   type: OrderingComparatorType,
-  axisName?: string,
+  axisName: string,
 ): string | [string, string] | undefined {
-  if (axisName) {
-    const axis = grid.categories.find((c) => c.name === axisName);
-    if (axis?.ordered === true) {
-      const phrase = axis.orderingPhrases?.comparators?.[type];
-      if (phrase !== undefined) return phrase;
-    }
-  }
-  return grid.spatialWords.comparators?.[type];
+  const axis = resolveAxis(grid, axisName);
+  const phrase = axis.orderingPhrases?.comparators?.[type];
+  return phrase ?? grid.spatialWords.comparators?.[type];
 }
 
 /**
@@ -55,7 +50,7 @@ function comparator(
 function symmetricComp(
   grid: Grid,
   type: OrderingComparatorType,
-  axisName?: string,
+  axisName: string,
 ): string | undefined {
   return comparator(grid, type, axisName) as string | undefined;
 }
@@ -71,7 +66,7 @@ function directionalComp(
   type: OrderingComparatorType,
   a: string,
   b: string,
-  axisName?: string,
+  axisName: string,
 ): { subject: string; object: string; phrase: string } | undefined {
   const c = comparator(grid, type, axisName);
   if (c === undefined) return undefined;
@@ -218,14 +213,8 @@ function renderText(constraint: Constraint, grid: Grid): string {
       const la = label(s, grid);
       const lb = label(o, grid);
       // Per-axis unit takes precedence over grid-level distanceUnit.
-      const axisCategory = grid.categories.find(
-        (c) => c.name === constraint.axis,
-      );
-      const axisUnit =
-        axisCategory?.ordered === true
-          ? axisCategory.orderingPhrases?.unit
-          : undefined;
-      const unit = axisUnit ?? w.distanceUnit;
+      const axisCategory = resolveAxis(grid, constraint.axis);
+      const unit = axisCategory.orderingPhrases?.unit ?? w.distanceUnit;
       const prefix =
         symmetricComp(grid, "exact_distance", constraint.axis) ??
         `${w.verb[0]} exactly`;
@@ -244,36 +233,27 @@ function renderText(constraint: Constraint, grid: Grid): string {
       // its verb to produce "Alice lives in the first house" (House's verb),
       // not "The first house plays piano" (Instrument's verb).
       const axis = orderedCategories(grid)[0];
-      if (axis) {
-        const axisVal = axis.values[constraint.position];
-        const cat = findCategory(constraint.value, grid);
-        const idx = 0;
-        // positionAdjective path: "The first house is red."
-        if (cat.positionAdjective) {
-          return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[idx]} ${constraint.value.toLowerCase()}.`;
-        }
-        const verb = axis.verb;
-        if (verb) {
-          return `${capitalize(label(constraint.value, grid))} ${verb[idx]} ${objectValue(axisVal, grid)}.`;
-        }
+      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(label(axisVal, grid))} ${cat.positionAdjective[0]} ${constraint.value.toLowerCase()}.`;
       }
-      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[0]} position ${constraint.position + 1}.`;
+      if (!axis.verb)
+        throw new Error(`Ordered category "${axis.name}" has no verb`);
+      return `${capitalize(label(constraint.value, grid))} ${axis.verb[0]} ${objectValue(axisVal, grid)}.`;
     }
     case "not_at_position": {
       const axis = orderedCategories(grid)[0];
-      if (axis) {
-        const axisVal = axis.values[constraint.position];
-        const cat = findCategory(constraint.value, grid);
-        const idx = 1;
-        if (cat.positionAdjective) {
-          return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[idx]} ${constraint.value.toLowerCase()}.`;
-        }
-        const verb = axis.verb;
-        if (verb) {
-          return `${capitalize(label(constraint.value, grid))} ${verb[idx]} ${objectValue(axisVal, grid)}.`;
-        }
+      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(label(axisVal, grid))} ${cat.positionAdjective[1]} ${constraint.value.toLowerCase()}.`;
       }
-      return `${capitalize(label(constraint.value, grid))} ${w.atPosition[1]} position ${constraint.position + 1}.`;
+      if (!axis.verb)
+        throw new Error(`Ordered category "${axis.name}" has no verb`);
+      return `${capitalize(label(constraint.value, grid))} ${axis.verb[1]} ${objectValue(axisVal, grid)}.`;
     }
   }
 }
diff --git a/packages/logic-grid/src/deduce/constraints.test.ts b/packages/logic-grid/src/deduce/constraints.test.ts
index 2b66a95..5caf693 100644
--- a/packages/logic-grid/src/deduce/constraints.test.ts
+++ b/packages/logic-grid/src/deduce/constraints.test.ts
@@ -1010,4 +1010,207 @@ describe("rank-space deduction on non-pinned axis", () => {
       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,
+        },
+        {
+          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],
+        },
+      ],
+    });
+    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/state.test.ts b/packages/logic-grid/src/deduce/state.test.ts
index 225adbc..bfa3d38 100644
--- a/packages/logic-grid/src/deduce/state.test.ts
+++ b/packages/logic-grid/src/deduce/state.test.ts
@@ -60,6 +60,22 @@ describe("describeResult", () => {
   });
 });
 
+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"] },
+      ],
+      positionNoun: ["house", "houses"] as [string, string],
+      positionPreposition: "in",
+      spatialWords: defaultGrid.spatialWords,
+    };
+    expect(() => createState(bare)).toThrow("no ordered category");
+  });
+});
+
 describe("describeKnown", () => {
   // makeGrid auto-prepends a House category; Name is now categories[1].
   it("uses default house/in for assigned value", () => {
diff --git a/packages/logic-grid/src/deduce/state.ts b/packages/logic-grid/src/deduce/state.ts
index 145be92..7558122 100644
--- a/packages/logic-grid/src/deduce/state.ts
+++ b/packages/logic-grid/src/deduce/state.ts
@@ -87,15 +87,14 @@ export function createState(grid: Grid): DeduceState {
       valueInfo.set(grid.categories[ci].values[vi], [ci, vi]);
     }
   }
-  // Phase 1: identity-pin the first ordered category to match randomSolution
-  // and encodeBase behavior. Phase 2 removes this.
+  // Identity-pin the first ordered category to match randomSolution and
+  // encodeBase behavior.
   const firstOrderedIdx = grid.categories.findIndex((c) => c.ordered === true);
-  if (firstOrderedIdx >= 0) {
-    const cat = grid.categories[firstOrderedIdx];
-    for (let vi = 0; vi < cat.values.length; vi++) {
-      possible[firstOrderedIdx][vi].clear();
-      possible[firstOrderedIdx][vi].add(vi);
-    }
+  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 };
 }
diff --git a/packages/logic-grid/src/encoding.test.ts b/packages/logic-grid/src/encoding.test.ts
index a63920f..a8f9b95 100644
--- a/packages/logic-grid/src/encoding.test.ts
+++ b/packages/logic-grid/src/encoding.test.ts
@@ -2,7 +2,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 { DEFAULT_SPATIAL_WORDS } from "./default-config";
+import type { Constraint, Grid } from "./types";
 
 const grid3x3 = makeGrid({
   size: 3,
@@ -333,6 +334,23 @@ describe("encodeConstraint", () => {
   });
 });
 
+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"] },
+      ],
+      positionNoun: ["house", "houses"],
+      positionPreposition: "in",
+      spatialWords: { ...DEFAULT_SPATIAL_WORDS },
+    };
+    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
diff --git a/packages/logic-grid/src/encoding.ts b/packages/logic-grid/src/encoding.ts
index 4c87f71..c603fc7 100644
--- a/packages/logic-grid/src/encoding.ts
+++ b/packages/logic-grid/src/encoding.ts
@@ -241,15 +241,13 @@ export function encodeBase(ctx: EncodingContext): number[][] {
     }
   }
 
-  // Phase 1: identity-pin the first ordered category. This matches the
-  // generator's randomSolution behavior and keeps the row-based encoder
+  // 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.
-  // Phase 2 removes this when the encoder switches to rank-forbidding.
   const firstOrdered = grid.categories.find((c) => c.ordered === true);
-  if (firstOrdered) {
-    for (let i = 0; i < firstOrdered.values.length; i++) {
-      clauses.push([variable(ctx, firstOrdered.values[i], i)]);
-    }
+  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;
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index fb4ab06..584f45d 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -386,6 +386,79 @@ describe("generate", () => {
     ).toThrow('Category "Color" has 2 values but size is 5');
   });
 
+  it("throws on duplicate category names", () => {
+    expect(() =>
+      generate({
+        size: 3,
+        categoryNames: [
+          { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+          {
+            name: "Dupe",
+            values: ["A", "B", "C"],
+            noun: "x",
+            verb: ["is", "is not"],
+          },
+          {
+            name: "Dupe",
+            values: ["D", "E", "F"],
+            noun: "y",
+            verb: ["has", "has not"],
+          },
+        ],
+      }),
+    ).toThrow("Duplicate category name");
+  });
+
+  it("throws when numericValues length does not match values", () => {
+    expect(() =>
+      generate({
+        size: 3,
+        categoryNames: [
+          { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+          {
+            name: "Year",
+            values: ["2020", "2021", "2022"],
+            noun: "year",
+            verb: ["started in", "did not start in"],
+            ordered: true,
+            numericValues: [2020, 2021],
+          },
+          {
+            name: "Color",
+            values: ["Red", "Blue", "Green"],
+            noun: "color",
+            verb: ["wears", "does not wear"],
+          },
+        ],
+      }),
+    ).toThrow("numericValues length must match values length");
+  });
+
+  it("throws when displayAxis references a non-ordered category", () => {
+    expect(() =>
+      generate({
+        size: 3,
+        categoryNames: [
+          { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
+          {
+            name: "Year",
+            values: ["2020", "2021", "2022"],
+            noun: "year",
+            verb: ["started in", "did not start in"],
+            ordered: true,
+          },
+          {
+            name: "Color",
+            values: ["Red", "Blue", "Green"],
+            noun: "color",
+            verb: ["wears", "does not wear"],
+          },
+        ],
+        displayAxis: "Color",
+      }),
+    ).toThrow("must reference an ordered category");
+  });
+
   it("throws when non-person category lacks verb", () => {
     expect(() =>
       generate({

From 665db993fece75d060ae6b02c385282e171c4fe4 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 17:24:29 +0200
Subject: [PATCH 10/24] refactor: remove SpatialWords, require comparators via
 types
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove SpatialWords from Grid and all grid-level rendering defaults.
Comparative clue rendering now comes exclusively from each ordered
category's orderingPhrases.comparators — no fallbacks, no defaults.

Type-level enforcement:
- ComparatorMap is now Record (all 7 keys required), not Partial
- OrderingPhrases.comparators is required, not optional
- orderingPhrases is required on ordered categories
- OrderedCategory type returned by resolveAxis gives full access
  without non-null assertions
- Validator accepts RawCategory (loose) for untrusted AI input

Removed: SpatialWords, Grid.positionNoun, Grid.positionPreposition,
Grid.spatialWords, GenerateOptions.positionNoun/positionPreposition,
DEFAULT_SPATIAL_WORDS, DEFAULT_POSITION_NOUN, DEFAULT_POSITION_PREPOSITION,
ThemeResult.positionNoun/positionPreposition, posNoun/posPrep/posNounPlural.

Default House carries full comparators and unit. Deduction explanations
use generic "position"/"in" (follow-up to make axis-aware).

AI prompt updated to require comparators on ordered categories with
good/bad phrasing examples and rank-vs-value guidance.

Zero eslint-disables. Zero as-any casts. 100% coverage.
---
 packages/demo/src/lib/PuzzleGrid.svelte       |   2 +-
 packages/demo/src/lib/puzzle-state.svelte.ts  |  18 +-
 packages/demo/src/routes/+page.svelte         |  10 -
 packages/logic-grid-ai/src/theme.test.ts      |  34 +--
 packages/logic-grid-ai/src/theme.ts           |  46 ++--
 packages/logic-grid-ai/src/types.ts           |   2 -
 packages/logic-grid-ai/src/validation.test.ts | 211 ++++++------------
 packages/logic-grid-ai/src/validation.ts      |  79 +++----
 packages/logic-grid/src/axis.test.ts          |   4 +-
 packages/logic-grid/src/axis.ts               |   6 +-
 .../logic-grid/src/clues/templates.test.ts    | 207 +++++++----------
 packages/logic-grid/src/clues/templates.ts    |  57 ++---
 .../deduce/__snapshots__/index.test.ts.snap   |  28 +--
 .../logic-grid/src/deduce/constraints.test.ts | 102 +++++++--
 packages/logic-grid/src/deduce/constraints.ts |  31 +--
 .../logic-grid/src/deduce/contradiction.ts    |   6 +-
 packages/logic-grid/src/deduce/state.test.ts  |  73 ++----
 packages/logic-grid/src/deduce/state.ts       |  13 +-
 packages/logic-grid/src/deduce/structural.ts  |  14 +-
 packages/logic-grid/src/default-config.ts     |  30 ++-
 packages/logic-grid/src/encoding.test.ts      |  11 +-
 packages/logic-grid/src/generator.test.ts     |  64 ++----
 packages/logic-grid/src/generator.ts          |  50 +----
 packages/logic-grid/src/grid-utils.test.ts    |  54 +----
 packages/logic-grid/src/grid-utils.ts         |  18 --
 packages/logic-grid/src/index.ts              |   7 +-
 packages/logic-grid/src/test-helpers.ts       |  33 ++-
 packages/logic-grid/src/types.ts              |  53 ++---
 28 files changed, 474 insertions(+), 789 deletions(-)

diff --git a/packages/demo/src/lib/PuzzleGrid.svelte b/packages/demo/src/lib/PuzzleGrid.svelte
index 6d5ecad..56f4105 100644
--- a/packages/demo/src/lib/PuzzleGrid.svelte
+++ b/packages/demo/src/lib/PuzzleGrid.svelte
@@ -96,7 +96,7 @@
       <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>
diff --git a/packages/demo/src/lib/puzzle-state.svelte.ts b/packages/demo/src/lib/puzzle-state.svelte.ts
index 5ca6146..4fe2ad3 100644
--- a/packages/demo/src/lib/puzzle-state.svelte.ts
+++ b/packages/demo/src/lib/puzzle-state.svelte.ts
@@ -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) {
diff --git a/packages/demo/src/routes/+page.svelte b/packages/demo/src/routes/+page.svelte
index a723b21..7d0ae0d 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> = {
@@ -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",
@@ -85,8 +81,6 @@
         { 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)",
@@ -136,8 +130,6 @@
         },
         { name: "Fund", values: ["Black River", "Citizen Trust", "Pine Bay", "Silver Rock"], noun: "fund", subjectPriority: 1, verb: ["runs", "does not run"], valueSuffix: "fund" },
       ],
-      positionNoun: ["fund", "funds"],
-      positionPreposition: "at",
     },
   };
 
@@ -159,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/src/theme.test.ts b/packages/logic-grid-ai/src/theme.test.ts
index f6a61ed..14aa9e1 100644
--- a/packages/logic-grid-ai/src/theme.test.ts
+++ b/packages/logic-grid-ai/src/theme.test.ts
@@ -23,6 +23,17 @@ const VALID_THEME: ThemeResult = {
       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",
@@ -37,8 +48,6 @@ const VALID_THEME: ThemeResult = {
       verb: ["wields the", "does not wield the"],
     },
   ],
-  positionNoun: ["spot", "spots"],
-  positionPreposition: "at",
 };
 
 describe("generateTheme", () => {
@@ -52,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 () => {
@@ -126,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(
@@ -192,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 73335c0..aead541 100644
--- a/packages/logic-grid-ai/src/theme.ts
+++ b/packages/logic-grid-ai/src/theme.ts
@@ -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"],
   };
 }
 
@@ -145,10 +132,6 @@ The puzzle has ${size} positions. Clues are generated mechanically from categori
 
 **\`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
-
-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.
-
 ## Ordered categories
 
 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:
@@ -157,7 +140,22 @@ At least one category must have \`ordered: true\` so comparative constraints can
 - 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"]\`.
 
-**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", "the next higher/lower". Only \`exact_distance\` may claim specific value gaps (it uses numericValues to compute the actual difference).
+**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."
+
+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 OPTIONAL** — but without them, clues fall back to generic "lives next to" / "lives left of" phrasing that only works for spatial themes (houses, docks, seats). For any non-spatial ordered category (scores, times, prices, years), you MUST set comparators for at least: \`before\`, \`left_of\`, \`next_to\`, \`not_next_to\`.
+
+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
 
@@ -170,8 +168,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."
@@ -181,12 +177,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"], "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 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": "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
@@ -208,7 +202,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(", ")}`;
@@ -224,7 +218,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 bfa8e94..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,18 +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",
   };
 }
 
@@ -54,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"'),
@@ -79,89 +87,73 @@ describe("validateThemeResult", () => {
     );
   });
 
-  it("rejects whitespace-only noun", () => {
-    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", () => {
+  it("rejects invalid verb type", () => {
     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", () => {
@@ -173,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;
@@ -219,15 +175,15 @@ 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 an ordered category with numericValues and orderingPhrases", () => {
     const r = validResult();
-    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" },
     };
@@ -236,8 +192,7 @@ describe("validateThemeResult", () => {
 
   it("rejects when no category is ordered", () => {
     const r = validResult();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-    delete (r.categories[1] as any).ordered;
+    delete (r.categories[1] as Record<string, unknown>).ordered;
     const errors = validateThemeResult(r, 3, 3);
     expect(errors).toContainEqual(
       expect.stringContaining("No ordered category found"),
@@ -246,13 +201,13 @@ describe("validateThemeResult", () => {
 
   it("accepts multiple ordered categories", () => {
     const r = validResult();
-    r.categories[2].ordered = true;
+    (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"),
@@ -261,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", () => {
+  it("accepts orderingPhrases with unit on ordered category", () => {
     const r = validResult();
-    r.categories[1].numericValues = [10, 20, 30];
-    expect(validateThemeResult(r, 3, 3)).toEqual([]);
-  });
-
-  it("accepts orderingPhrases on non-position 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([]);
@@ -285,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(
@@ -338,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"),
@@ -355,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"),
@@ -364,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(
@@ -378,18 +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 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 9ef5cba..6fb6e05 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: RawCategory[] },
   expectedSize: number,
   expectedCategories: number,
 ): string[] {
@@ -54,14 +74,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) {
@@ -220,53 +241,5 @@ export function validateThemeResult(
     );
   }
 
-  // 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/src/axis.test.ts b/packages/logic-grid/src/axis.test.ts
index 7fd3961..48f454a 100644
--- a/packages/logic-grid/src/axis.test.ts
+++ b/packages/logic-grid/src/axis.test.ts
@@ -6,7 +6,7 @@ import {
   displayAxisCategory,
   validateConstraints,
 } from "./axis";
-import { makeGrid } from "./test-helpers";
+import { makeGrid, TEST_COMPARATORS } from "./test-helpers";
 
 const grid = makeGrid({
   size: 3,
@@ -18,6 +18,7 @@ const grid = makeGrid({
       noun: "fund",
       verb: ["started in", "did not start in"],
       ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
     },
     {
       name: "Return",
@@ -25,6 +26,7 @@ const grid = makeGrid({
       noun: "fund",
       verb: ["has a return of", "does not have a return of"],
       ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
     },
   ],
 });
diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
index 8deaa1b..bb2b46a 100644
--- a/packages/logic-grid/src/axis.ts
+++ b/packages/logic-grid/src/axis.ts
@@ -1,4 +1,4 @@
-import type { Category, Constraint, Grid } from "./types";
+import type { Category, Constraint, Grid, OrderedCategory } from "./types";
 
 /**
  * Return the list of `ordered: true` categories in declaration order.
@@ -12,7 +12,7 @@ export function orderedCategories(grid: Grid): Category[] {
  * 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): Category {
+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}"`);
@@ -22,7 +22,7 @@ export function resolveAxis(grid: Grid, axisName: string): Category {
       `Axis "${axisName}" must reference an ordered category`,
     );
   }
-  return cat;
+  return cat as OrderedCategory;
 }
 
 /**
diff --git a/packages/logic-grid/src/clues/templates.test.ts b/packages/logic-grid/src/clues/templates.test.ts
index ebd25bd..3ba8206 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -1,8 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { renderClue } from "./templates";
-import { DEFAULT_SPATIAL_WORDS } from "../default-config";
-import { makeGrid } from "../test-helpers";
-import type { Grid, SpatialWords } from "../types";
+import { makeGrid, TEST_COMPARATORS } from "../test-helpers";
+import type { Grid } from "../types";
 
 const grid = makeGrid({
   size: 3,
@@ -252,9 +251,7 @@ describe("renderClue — comparatives on House axis", () => {
       },
       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", () => {
@@ -268,7 +265,7 @@ describe("renderClue — comparatives on House axis", () => {
       },
       grid,
     );
-    expect(clue.text).toBe("Alice lives exactly one house from the cat owner.");
+    expect(clue.text).toBe("Alice lives exactly 1 house from the cat owner.");
   });
 });
 
@@ -306,22 +303,45 @@ describe("custom category noun/verb", () => {
   });
 });
 
-describe("grid-level comparator overrides", () => {
-  const withComparators: Grid = {
-    ...grid,
-    spatialWords: {
-      ...grid.spatialWords,
-      comparators: {
-        before: "comes earlier than",
-        left_of: "is directly before",
-        next_to: "is adjacent to",
-        not_next_to: "is not adjacent to",
-        between: "is between",
-        not_between: "is not between",
-        exact_distance: "is exactly",
+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",
+            left_of: "is directly before",
+            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: "Pet",
+        values: ["Cat", "Dog", "Fish"],
+        noun: "owner",
+        verb: ["owns the", "does not own the"],
+        subjectPriority: 1,
+      },
+    ],
+  });
 
   it("left_of uses grid comparator when set", () => {
     const clue = renderClue(
@@ -393,102 +413,41 @@ describe("grid-level comparator overrides", () => {
 });
 
 describe("before with tuple comparator picks forward or reverse", () => {
-  const withTuple: Grid = {
-    ...grid,
-    spatialWords: {
-      ...grid.spatialWords,
-      comparators: {
-        before: ["has a lower return than", "has a higher return than"],
-      },
-    },
-  };
-
+  // 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" },
-      withTuple,
+      grid,
     );
     expect(aliceBob.text).toMatch(
-      /^(Alice has a lower return than Bob|Bob has a higher return than Alice)\.$/,
+      /^(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" },
-      withTuple,
+      grid,
     );
     expect(again.text).toBe(aliceBob.text);
   });
 });
 
-describe("distance unit from spatialWords.distanceUnit", () => {
-  const withUnit: Grid = {
-    ...grid,
-    spatialWords: {
-      ...grid.spatialWords,
-      distanceUnit: ["percentage point", "percentage points"],
-    },
-  };
-
-  it("exact_distance singular", () => {
-    const clue = renderClue(
-      {
-        type: "exact_distance",
-        a: "Alice",
-        b: "Cat",
-        distance: 1,
-        axis: "House",
-      },
-      withUnit,
-    );
-    expect(clue.text).toBe(
-      "Alice lives exactly 1 percentage point from the cat owner.",
-    );
-  });
-
-  it("exact_distance plural", () => {
-    const clue = renderClue(
-      {
-        type: "exact_distance",
-        a: "Alice",
-        b: "Cat",
-        distance: 2,
-        axis: "House",
-      },
-      withUnit,
-    );
-    expect(clue.text).toBe(
-      "Alice lives exactly 2 percentage points from the cat owner.",
-    );
-  });
-});
-
 describe("left_of with tuple comparator picks forward or reverse", () => {
-  const withTupleLeftOf: Grid = {
-    ...grid,
-    spatialWords: {
-      ...grid.spatialWords,
-      comparators: {
-        left_of: ["is right before", "is right after"] as [string, string],
-      },
-    },
-  };
-
   it("picks reverse phrasing when hash tiebreaker selects b as subject", () => {
     // simpleHash("Alice"+"Bob") % 2 === 1 → reverse: Bob is subject
     const clue = renderClue(
       { type: "left_of", a: "Alice", b: "Bob", axis: "House" },
-      withTupleLeftOf,
+      grid,
     );
-    expect(clue.text).toBe("Bob is right after Alice.");
+    expect(clue.text).toBe("Bob lives directly right of Alice.");
   });
 
   it("picks forward phrasing when hash tiebreaker selects a as subject", () => {
     // simpleHash("Bob"+"Carol") % 2 === 0 → forward: Bob is subject
     const clue = renderClue(
       { type: "left_of", a: "Bob", b: "Carol", axis: "House" },
-      withTupleLeftOf,
+      grid,
     );
-    expect(clue.text).toBe("Bob is right before Carol.");
+    expect(clue.text).toBe("Bob lives directly left of Carol.");
   });
 });
 
@@ -515,7 +474,15 @@ describe("per-axis orderingPhrases in rendering", () => {
               string,
               string,
             ],
-            next_to: "was begun in the closest year to",
+            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",
           },
         },
       },
@@ -532,6 +499,15 @@ describe("per-axis orderingPhrases in rendering", () => {
               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",
           },
         },
       },
@@ -559,16 +535,15 @@ describe("per-axis orderingPhrases in rendering", () => {
       { type: "next_to", a: "Alice", b: "Bob", axis: "Year" },
       multiGrid,
     );
-    expect(clue.text).toContain("was begun in the closest year to");
+    expect(clue.text).toContain("was begun right before or after");
   });
 
-  it("next_to falls through to grid defaults when axis=Return (no next_to override)", () => {
+  it("next_to uses Return axis comparators when axis=Return", () => {
     const clue = renderClue(
       { type: "next_to", a: "Alice", b: "Bob", axis: "Return" },
       multiGrid,
     );
-    // Return has no next_to comparator → falls through to spatial words default.
-    expect(clue.text).toMatch(/lives next to/);
+    expect(clue.text).toContain("has the return right above or below");
   });
 
   it("exact_distance uses per-axis unit when axis has one", () => {
@@ -585,7 +560,7 @@ describe("per-axis orderingPhrases in rendering", () => {
     expect(clue.text).toContain("2 percentage points");
   });
 
-  it("exact_distance uses grid default when axis has no unit", () => {
+  it("exact_distance without unit uses bare number", () => {
     const clue = renderClue(
       {
         type: "exact_distance",
@@ -596,8 +571,8 @@ describe("per-axis orderingPhrases in rendering", () => {
       },
       multiGrid,
     );
-    // Year has no unit → falls through to cardinals ("two houses").
-    expect(clue.text).toContain("two houses");
+    // Year has no unit → bare number.
+    expect(clue.text).toContain("2 from");
   });
 });
 
@@ -605,9 +580,6 @@ describe("at_position / not_at_position invariants", () => {
   const bareGrid: Grid = {
     size: 3,
     categories: [{ name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" }],
-    positionNoun: ["house", "houses"],
-    positionPreposition: "in",
-    spatialWords: DEFAULT_SPATIAL_WORDS,
   };
 
   it("at_position throws when grid has no ordered category", () => {
@@ -633,11 +605,13 @@ describe("at_position / not_at_position invariants", () => {
       size: 3,
       categories: [
         { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-        { name: "Axis", values: ["X", "Y", "Z"], ordered: true },
+        {
+          name: "Axis",
+          values: ["X", "Y", "Z"],
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
       ],
-      positionNoun: ["house", "houses"],
-      positionPreposition: "in",
-      spatialWords: DEFAULT_SPATIAL_WORDS,
     };
     expect(() =>
       renderClue(
@@ -652,11 +626,13 @@ describe("at_position / not_at_position invariants", () => {
       size: 3,
       categories: [
         { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-        { name: "Axis", values: ["X", "Y", "Z"], ordered: true },
+        {
+          name: "Axis",
+          values: ["X", "Y", "Z"],
+          ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
+        },
       ],
-      positionNoun: ["house", "houses"],
-      positionPreposition: "in",
-      spatialWords: DEFAULT_SPATIAL_WORDS,
     };
     expect(() =>
       renderClue(
@@ -666,14 +642,3 @@ describe("at_position / not_at_position invariants", () => {
     ).toThrow("has no verb");
   });
 });
-
-describe("default spatial words sanity", () => {
-  it("DEFAULT_SPATIAL_WORDS has expected shape", () => {
-    const w: SpatialWords = DEFAULT_SPATIAL_WORDS;
-    expect(w.verb).toEqual(["lives", "does not live"]);
-    expect(w.adjacency).toBe("next to");
-    expect(w.direction).toEqual(["left of", "right of"]);
-    expect(w.between).toBe("somewhere between");
-    expect(w.cardinals.length).toBeGreaterThanOrEqual(4);
-  });
-});
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 3d6099a..f65431e 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -5,7 +5,7 @@ import type {
   Grid,
   OrderingComparatorType,
 } from "../types";
-import { posNoun, posNounPlural } from "../grid-utils";
+// posNoun/posNounPlural no longer used — all rendering comes from axis comparators.
 import { orderedCategories, resolveAxis } from "../axis";
 
 function findCategory(value: string, grid: Grid): Category {
@@ -37,10 +37,9 @@ function comparator(
   grid: Grid,
   type: OrderingComparatorType,
   axisName: string,
-): string | [string, string] | undefined {
+): string | [string, string] {
   const axis = resolveAxis(grid, axisName);
-  const phrase = axis.orderingPhrases?.comparators?.[type];
-  return phrase ?? grid.spatialWords.comparators?.[type];
+  return axis.orderingPhrases.comparators[type];
 }
 
 /**
@@ -51,8 +50,8 @@ function symmetricComp(
   grid: Grid,
   type: OrderingComparatorType,
   axisName: string,
-): string | undefined {
-  return comparator(grid, type, axisName) as string | undefined;
+): string {
+  return comparator(grid, type, axisName) as string;
 }
 
 /**
@@ -67,9 +66,8 @@ function directionalComp(
   a: string,
   b: string,
   axisName: string,
-): { subject: string; object: string; phrase: string } | undefined {
+): { subject: string; object: string; phrase: string } {
   const c = comparator(grid, type, axisName);
-  if (c === undefined) return undefined;
   if (typeof c === "string") {
     return { subject: a, object: b, phrase: c };
   }
@@ -140,7 +138,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);
@@ -149,12 +146,12 @@ function renderText(constraint: Constraint, grid: Grid): string {
     case "next_to": {
       const [s, o] = ordered(constraint.a, constraint.b, grid);
       const comp = symmetricComp(grid, "next_to", constraint.axis);
-      return `${capitalize(label(s, grid))} ${comp ?? `${w.verb[0]} ${w.adjacency}`} ${label(o, grid)}.`;
+      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", constraint.axis);
-      return `${capitalize(label(s, grid))} ${comp ?? `${w.verb[1]} ${w.adjacency}`} ${label(o, grid)}.`;
+      return `${capitalize(label(s, grid))} ${comp} ${label(o, grid)}.`;
     }
     case "left_of": {
       const comp = directionalComp(
@@ -164,34 +161,21 @@ function renderText(constraint: Constraint, grid: Grid): string {
         constraint.b,
         constraint.axis,
       );
-      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)}.`;
+      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", constraint.axis);
-      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}.`;
+      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", constraint.axis);
-      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}.`;
+      return `${capitalize(lm)} ${comp} ${lo1} and ${lo2}.`;
     }
     case "before": {
       const comp = directionalComp(
@@ -201,31 +185,20 @@ function renderText(constraint: Constraint, grid: Grid): string {
         constraint.b,
         constraint.axis,
       );
-      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)}.`;
+      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);
-      // Per-axis unit takes precedence over grid-level distanceUnit.
       const axisCategory = resolveAxis(grid, constraint.axis);
-      const unit = axisCategory.orderingPhrases?.unit ?? w.distanceUnit;
-      const prefix =
-        symmetricComp(grid, "exact_distance", constraint.axis) ??
-        `${w.verb[0]} exactly`;
+      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": {
       // Render using the first ordered category's value at this position.
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 5caf693..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,
@@ -342,6 +333,71 @@ 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 },
@@ -373,6 +429,7 @@ describe("deduce constraint types", () => {
           subjectPriority: -1,
           ordered: true,
           numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
@@ -408,6 +465,7 @@ describe("deduce constraint types", () => {
           subjectPriority: -1,
           ordered: true,
           numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
@@ -448,7 +506,7 @@ describe("deduce constraint types", () => {
     expect(step!.explanation).toContain("1 house apart");
   });
 
-  it("exact_distance explanation uses unit from spatialWords", () => {
+  it("exact_distance explanation uses unit from orderingPhrases", () => {
     const unitGrid = makeGrid({
       size: 4,
       categories: [
@@ -460,12 +518,12 @@ describe("deduce constraint types", () => {
           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"],
-      },
     });
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
@@ -495,12 +553,12 @@ describe("deduce constraint types", () => {
           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"],
-      },
     });
     const constraints: Constraint[] = [
       { type: "at_position", value: "Alice", position: 0 },
@@ -947,6 +1005,7 @@ describe("rank-space deduction on non-pinned axis", () => {
         noun: "fund",
         verb: ["was begun in", "was not begun in"],
         ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
       },
       {
         name: "Return",
@@ -954,6 +1013,7 @@ describe("rank-space deduction on non-pinned axis", () => {
         noun: "fund",
         verb: ["has a return of", "does not have a return of"],
         ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
       },
     ],
   });
@@ -1108,6 +1168,7 @@ describe("rank-space deduction on non-pinned axis", () => {
           noun: "fund",
           verb: ["started in", "did not start in"],
           ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
         {
           name: "Return",
@@ -1116,6 +1177,7 @@ describe("rank-space deduction on non-pinned axis", () => {
           verb: ["has a return of", "does not have a return of"],
           ordered: true,
           numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
diff --git a/packages/logic-grid/src/deduce/constraints.ts b/packages/logic-grid/src/deduce/constraints.ts
index bd540ac..5772a15 100644
--- a/packages/logic-grid/src/deduce/constraints.ts
+++ b/packages/logic-grid/src/deduce/constraints.ts
@@ -4,7 +4,7 @@ import type {
   DeductionStep,
   DeductionTechnique,
 } from "../types";
-import { ordinal, posNoun, posNounPlural, posPrep } from "../grid-utils";
+import { ordinal } from "../grid-utils";
 import { resolveAxis } from "../axis";
 import {
   type DeduceState,
@@ -154,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"}.`,
   );
 }
 
@@ -171,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}`,
   );
 }
 
@@ -217,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}.`;
@@ -254,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("; ")}.`
@@ -265,7 +265,7 @@ 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}`,
   );
 }
 
@@ -580,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}`,
@@ -664,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):
@@ -848,10 +848,11 @@ 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 axisForUnit = resolveAxis(state.grid, c.axis);
+  const unit = axisForUnit.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/state.test.ts b/packages/logic-grid/src/deduce/state.test.ts
index bfa3d38..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,52 +10,25 @@ 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("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("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 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",
     );
   });
 });
@@ -68,9 +41,6 @@ describe("createState invariant", () => {
         { name: "A", values: ["a1", "a2", "a3"] },
         { name: "B", values: ["b1", "b2", "b3"] },
       ],
-      positionNoun: ["house", "houses"] as [string, string],
-      positionPreposition: "in",
-      spatialWords: defaultGrid.spatialWords,
     };
     expect(() => createState(bare)).toThrow("no ordered category");
   });
@@ -78,29 +48,22 @@ describe("createState invariant", () => {
 
 describe("describeKnown", () => {
   // makeGrid auto-prepends a House category; Name is now categories[1].
-  it("uses default house/in for assigned value", () => {
-    const state = createState(defaultGrid);
-    // Pin Alice (categories[1] = Name, values[0] = "Alice") to position 0
+  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 house");
-  });
-
-  it("uses custom noun and preposition for assigned value", () => {
-    const state = createState(seatGrid);
-    state.possible[1][0].clear();
-    state.possible[1][0].add(0);
-    expect(describeKnown(state, "Alice")).toBe("Alice is at the first seat");
+    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
+  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 7558122..5eb60f6 100644
--- a/packages/logic-grid/src/deduce/state.ts
+++ b/packages/logic-grid/src/deduce/state.ts
@@ -4,17 +4,17 @@ import type {
   DeductionStep,
   DeductionTechnique,
 } from "../types";
-import { ordinal, posNoun, posPrep } from "../grid-utils";
+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}`);
@@ -40,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);
diff --git a/packages/logic-grid/src/deduce/structural.ts b/packages/logic-grid/src/deduce/structural.ts
index 0188d0c..d5714b7 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 9df6e42..962c0f2 100644
--- a/packages/logic-grid/src/default-config.ts
+++ b/packages/logic-grid/src/default-config.ts
@@ -1,4 +1,4 @@
-import type { Category, SpatialWords } from "./types";
+import type { Category } from "./types";
 
 /**
  * Default non-position category pool for the classic Einstein's riddle style.
@@ -111,22 +111,6 @@ export const DEFAULT_CATEGORIES: Category[] = [
   },
 ];
 
-/** Generic fallback vocabulary used when an axis category supplies no overrides. */
-export const DEFAULT_SPATIAL_WORDS: 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 singular/plural position noun for the auto-added House category's display. */
-export const DEFAULT_POSITION_NOUN: [string, string] = ["house", "houses"];
-
-/** Default preposition for positional phrases. */
-export const DEFAULT_POSITION_PREPOSITION = "in";
-
 /**
  * Build the auto-added House ordered category. Used by `buildGrid` when the
  * user supplies no ordered category. noun + valueSuffix both set so label()
@@ -154,5 +138,17 @@ export function defaultHouseCategory(size: number): Category {
     valueSuffix: "house",
     ordered: true,
     values: ordinals.slice(0, size),
+    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/encoding.test.ts b/packages/logic-grid/src/encoding.test.ts
index a8f9b95..451bd0e 100644
--- a/packages/logic-grid/src/encoding.test.ts
+++ b/packages/logic-grid/src/encoding.test.ts
@@ -1,8 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { createContext, variable, encodeBase, encodePuzzle } from "./encoding";
 import { solveSAT, solveAllSAT } from "./sat";
-import { makeGrid } from "./test-helpers";
-import { DEFAULT_SPATIAL_WORDS } from "./default-config";
+import { makeGrid, TEST_COMPARATORS } from "./test-helpers";
 import type { Constraint, Grid } from "./types";
 
 const grid3x3 = makeGrid({
@@ -278,6 +277,7 @@ describe("encodeConstraint", () => {
           verb: ["drives the", "does not drive the"],
           ordered: true,
           numericValues: [1980, 1990, 2005],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
@@ -342,9 +342,6 @@ describe("encodeBase invariant", () => {
         { name: "A", values: ["a1", "a2", "a3"] },
         { name: "B", values: ["b1", "b2", "b3"] },
       ],
-      positionNoun: ["house", "houses"],
-      positionPreposition: "in",
-      spatialWords: { ...DEFAULT_SPATIAL_WORDS },
     };
     const ctx = createContext(bare);
     expect(() => encodeBase(ctx)).toThrow("no ordered category");
@@ -367,6 +364,7 @@ describe("encodeConstraint on non-pinned ordered axis", () => {
         noun: "fund",
         verb: ["was begun in", "was not begun in"],
         ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
       },
       {
         name: "Return",
@@ -374,6 +372,7 @@ describe("encodeConstraint on non-pinned ordered axis", () => {
         noun: "fund",
         verb: ["has a return of", "does not have a return of"],
         ordered: true,
+        orderingPhrases: { comparators: TEST_COMPARATORS },
       },
     ],
   });
@@ -531,6 +530,7 @@ describe("encodeConstraint on non-pinned ordered axis", () => {
           noun: "fund",
           verb: ["was begun in", "was not begun in"],
           ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
         {
           name: "Return",
@@ -539,6 +539,7 @@ describe("encodeConstraint on non-pinned ordered axis", () => {
           verb: ["has a return of", "does not have a return of"],
           ordered: true,
           numericValues: [3, 5, 8, 12],
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
       ],
     });
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index 584f45d..1ce92bf 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -3,7 +3,18 @@ import { generate } from "./generator";
 import { deduce } from "./deduce";
 import { hasUniqueSolution, solve } from "./solver";
 import { resolveAxis } from "./axis";
-import type { Grid } from "./types";
+import type { Category, ComparatorMap, Grid } from "./types";
+
+/** Generic comparators for test ordered categories. */
+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",
+};
 
 describe("generate", () => {
   it("returns a valid puzzle with defaults", () => {
@@ -185,44 +196,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,
@@ -233,6 +206,7 @@ describe("generate", () => {
           noun: "house",
           verb: ["lives in", "does not live in"],
           ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
         {
           name: "Owner",
@@ -422,6 +396,7 @@ describe("generate", () => {
             verb: ["started in", "did not start in"],
             ordered: true,
             numericValues: [2020, 2021],
+            orderingPhrases: { comparators: TEST_COMPARATORS },
           },
           {
             name: "Color",
@@ -446,6 +421,7 @@ describe("generate", () => {
             noun: "year",
             verb: ["started in", "did not start in"],
             ordered: true,
+            orderingPhrases: { comparators: TEST_COMPARATORS },
           },
           {
             name: "Color",
@@ -496,6 +472,7 @@ describe("generate", () => {
             ordered: true,
             orderingPhrases: {
               comparators: {
+                ...TEST_COMPARATORS,
                 next_to: ["fwd", "rev"] as [string, string],
               },
             },
@@ -523,6 +500,7 @@ describe("generate", () => {
             noun: "slot",
             verb: ["is at", "is not at"],
             ordered: true,
+            orderingPhrases: { comparators: TEST_COMPARATORS },
             numericValues: [9, 7, 8],
           },
           { name: "Color", values: ["Red", "Blue", "Green"] },
@@ -546,6 +524,7 @@ describe("generate", () => {
           numericValues: [3, 5, 8, 12],
           orderingPhrases: {
             unit: ["percentage point", "percentage points"] as [string, string],
+            comparators: TEST_COMPARATORS,
           },
         },
         {
@@ -590,7 +569,7 @@ describe("generate", () => {
           numericValues: [6, 7, 8, 9],
           orderingPhrases: {
             unit: ["percentage point", "percentage points"] as [string, string],
-            comparators: { before: "has a lower return than" },
+            comparators: TEST_COMPARATORS,
           },
         },
         {
@@ -624,6 +603,7 @@ describe("generate", () => {
           noun: "slot",
           verb: ["is at", "is not at"],
           ordered: true,
+          orderingPhrases: { comparators: TEST_COMPARATORS },
         },
         {
           name: "Color",
@@ -641,7 +621,7 @@ describe("generate", () => {
 });
 
 describe("generate with multiple ordered categories", () => {
-  const hedgeFundCategories = [
+  const hedgeFundCategories: Category[] = [
     {
       name: "Manager",
       values: ["Alice", "Bob", "Carol", "Dan"],
@@ -655,6 +635,7 @@ describe("generate with multiple ordered categories", () => {
       verb: ["was begun in", "was not begun in"] as [string, string],
       subjectPriority: -1,
       ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
     },
     {
       name: "Return",
@@ -666,6 +647,7 @@ describe("generate with multiple ordered categories", () => {
       ],
       subjectPriority: -1,
       ordered: true,
+      orderingPhrases: { comparators: TEST_COMPARATORS },
     },
     {
       name: "Strategy",
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index 4a1d2f0..35d5ba0 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -17,13 +17,7 @@ import { renderClue } from "./clues/templates";
 import { classify, EASY_TYPES, MEDIUM_TYPES } from "./difficulty";
 import { deduce } from "./deduce";
 import { orderedCategories, resolveAxis } from "./axis";
-import {
-  DEFAULT_CATEGORIES,
-  DEFAULT_SPATIAL_WORDS,
-  DEFAULT_POSITION_NOUN,
-  DEFAULT_POSITION_PREPOSITION,
-  defaultHouseCategory,
-} from "./default-config";
+import { DEFAULT_CATEGORIES, defaultHouseCategory } from "./default-config";
 
 const MAX_RETRIES = 100;
 
@@ -38,11 +32,7 @@ const SYMMETRIC_COMPARATORS = new Set([
   "exact_distance",
 ]);
 
-function checkComparators(
-  scope: string,
-  comparators: ComparatorMap | undefined,
-): void {
-  if (!comparators) return;
+function checkComparators(scope: string, comparators: ComparatorMap): void {
   for (const [type, value] of Object.entries(comparators)) {
     if (Array.isArray(value) && SYMMETRIC_COMPARATORS.has(type)) {
       throw new RangeError(
@@ -85,7 +75,7 @@ function validateCategories(categories: Category[]): void {
           }
         }
       }
-      checkComparators(`Category "${c.name}"`, c.orderingPhrases?.comparators);
+      checkComparators(`Category "${c.name}"`, c.orderingPhrases.comparators);
     }
   }
 }
@@ -158,18 +148,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) {
@@ -202,30 +180,11 @@ function buildGrid(
 
   validateCategories(categories);
 
-  const posNoun = options?.positionNoun ?? DEFAULT_POSITION_NOUN;
-  const posPrep = options?.positionPreposition ?? DEFAULT_POSITION_PREPOSITION;
-
-  // Derive spatialWords.atPosition from the custom preposition so that
-  // "lives at the 3rd house" etc. flows from a non-default preposition.
-  const spatialWords: typeof DEFAULT_SPATIAL_WORDS = {
-    ...DEFAULT_SPATIAL_WORDS,
-  };
-  if (options?.positionPreposition !== undefined) {
-    spatialWords.atPosition = [
-      `${DEFAULT_SPATIAL_WORDS.verb[0]} ${posPrep}`,
-      `${DEFAULT_SPATIAL_WORDS.verb[1]} ${posPrep}`,
-    ];
-  }
-
   const grid: Grid = {
     size,
     categories,
-    positionNoun: posNoun,
-    positionPreposition: posPrep,
-    spatialWords,
     displayAxis: options?.displayAxis,
   };
-  checkComparators("Grid spatialWords", grid.spatialWords.comparators);
 
   // Validate displayAxis references an ordered category if set.
   if (grid.displayAxis !== undefined) {
@@ -291,9 +250,6 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
   const n = grid.size;
 
   const orderedCats = orderedCategories(grid);
-  /* v8 ignore next 2 */
-  if (orderedCats.length === 0)
-    throw new Error("Grid has no ordered category after buildGrid");
 
   // Build indexed arrays for fast access (avoid Map lookups in hot loops)
   const allValues: string[] = [];
diff --git a/packages/logic-grid/src/grid-utils.test.ts b/packages/logic-grid/src/grid-utils.test.ts
index a1c885a..9b58247 100644
--- a/packages/logic-grid/src/grid-utils.test.ts
+++ b/packages/logic-grid/src/grid-utils.test.ts
@@ -1,52 +1,14 @@
 import { describe, it, expect } from "vitest";
-import { posNoun, posNounPlural, posPrep } from "./grid-utils";
-import { makeGrid } from "./test-helpers";
+import { ordinal } from "./grid-utils";
 
-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");
+describe("ordinal", () => {
+  it("returns correct ordinals", () => {
+    expect(ordinal(0)).toBe("first");
+    expect(ordinal(7)).toBe("eighth");
   });
 
-  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 7b4eeeb..2d96587 100644
--- a/packages/logic-grid/src/grid-utils.ts
+++ b/packages/logic-grid/src/grid-utils.ts
@@ -1,5 +1,3 @@
-import type { Grid } from "./types";
-
 export const ORDINALS = [
   "first",
   "second",
@@ -16,19 +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;
-}
diff --git a/packages/logic-grid/src/index.ts b/packages/logic-grid/src/index.ts
index 8151e89..f229517 100644
--- a/packages/logic-grid/src/index.ts
+++ b/packages/logic-grid/src/index.ts
@@ -1,9 +1,5 @@
 export { generate } from "./generator";
-export {
-  DEFAULT_CATEGORIES,
-  DEFAULT_SPATIAL_WORDS,
-  defaultHouseCategory,
-} from "./default-config";
+export { DEFAULT_CATEGORIES, defaultHouseCategory } from "./default-config";
 export { solve, hasUniqueSolution } from "./solver";
 export { classify } from "./difficulty";
 export { deduce } from "./deduce";
@@ -37,7 +33,6 @@ export type {
   OrderingComparatorType,
   ComparatorPhrase,
   ComparatorMap,
-  SpatialWords,
   Grid,
   Assignment,
   Solution,
diff --git a/packages/logic-grid/src/test-helpers.ts b/packages/logic-grid/src/test-helpers.ts
index f3932a3..656ae2e 100644
--- a/packages/logic-grid/src/test-helpers.ts
+++ b/packages/logic-grid/src/test-helpers.ts
@@ -1,14 +1,20 @@
-import type { Category, Grid, SpatialWords } from "./types";
-import {
-  DEFAULT_SPATIAL_WORDS,
-  DEFAULT_POSITION_NOUN,
-  DEFAULT_POSITION_PREPOSITION,
-  defaultHouseCategory,
-} 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().
@@ -16,14 +22,8 @@ import {
 export function makeGrid(partial: {
   size: number;
   categories: Category[];
-  positionNoun?: [string, string];
-  positionPreposition?: string;
-  spatialWords?: SpatialWords;
   displayAxis?: string;
 }): Grid {
-  const positionNoun = partial.positionNoun ?? DEFAULT_POSITION_NOUN;
-  const positionPreposition =
-    partial.positionPreposition ?? DEFAULT_POSITION_PREPOSITION;
   let categories = partial.categories;
   if (!categories.some((c) => c.ordered === true)) {
     categories = [defaultHouseCategory(partial.size), ...categories];
@@ -31,9 +31,6 @@ export function makeGrid(partial: {
   return {
     size: partial.size,
     categories,
-    positionNoun,
-    positionPreposition,
-    spatialWords: partial.spatialWords ?? { ...DEFAULT_SPATIAL_WORDS },
     displayAxis: partial.displayAxis,
   };
 }
diff --git a/packages/logic-grid/src/types.ts b/packages/logic-grid/src/types.ts
index e27d7e7..0bbaf90 100644
--- a/packages/logic-grid/src/types.ts
+++ b/packages/logic-grid/src/types.ts
@@ -16,37 +16,15 @@ export type OrderingComparatorType =
  */
 export type ComparatorPhrase = string | [string, string];
 
-/** Map of constraint type → comparator phrase override. */
-export type ComparatorMap = Partial<
-  Record<OrderingComparatorType, ComparatorPhrase>
->;
+/** Map of constraint type → comparator phrase. All 7 keys required. */
+export type ComparatorMap = Record<OrderingComparatorType, ComparatorPhrase>;
 
 /** 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"]`. */
-  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;
 }
 
 /** Shared fields on every category. */
@@ -75,8 +53,8 @@ type OrderednessFields =
       ordered: true;
       /** 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. */
-      orderingPhrases?: OrderingPhrases;
+      /** Domain-specific phrasing for ordering constraints on this axis. Required on all ordered categories. */
+      orderingPhrases: OrderingPhrases;
     }
   | {
       ordered?: false;
@@ -105,16 +83,17 @@ type ValueSuffixFields =
 /** 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;
+  numericValues?: number[];
+  orderingPhrases: OrderingPhrases;
+} & 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;
-  /** Generic fallback vocabulary for composing ordering clue sentences. */
-  spatialWords: SpatialWords;
   /** 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;
 }
@@ -237,10 +216,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;
 }

From 68c58800d03d3cd2f4bea8dd180be690f5ac0955 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 17:25:58 +0200
Subject: [PATCH 11/24] fix(demo): add 'the' to Fund verb in multi-axis preset

---
 packages/demo/src/routes/+page.svelte | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/demo/src/routes/+page.svelte b/packages/demo/src/routes/+page.svelte
index 7d0ae0d..59afdc6 100644
--- a/packages/demo/src/routes/+page.svelte
+++ b/packages/demo/src/routes/+page.svelte
@@ -128,7 +128,7 @@
             },
           },
         },
-        { name: "Fund", values: ["Black River", "Citizen Trust", "Pine Bay", "Silver Rock"], noun: "fund", subjectPriority: 1, verb: ["runs", "does not run"], valueSuffix: "fund" },
+        { name: "Fund", values: ["Black River", "Citizen Trust", "Pine Bay", "Silver Rock"], noun: "fund", subjectPriority: 1, verb: ["runs the", "does not run the"], valueSuffix: "fund" },
       ],
     },
   };

From bef86d1a29552c620cffc4f070c983d2c61bf876 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 17:42:06 +0200
Subject: [PATCH 12/24] fix(ai): guide AI to use valueSuffix for bare numeric
 axis values
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add prompt guidance: orderingPhrases.unit only applies to
exact_distance clues. Bare numeric values like "500" that need a
label in all clue types should use valueSuffix instead (e.g.
valueSuffix: "gold pieces" → "has a bounty of 500 gold pieces").
Self-explanatory values like "2005" or "7am" need no suffix.
---
 packages/logic-grid-ai/src/theme.ts        | 3 +++
 packages/logic-grid/src/axis.ts            | 4 ++--
 packages/logic-grid/src/clues/templates.ts | 4 ----
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/packages/logic-grid-ai/src/theme.ts b/packages/logic-grid-ai/src/theme.ts
index aead541..157c0c6 100644
--- a/packages/logic-grid-ai/src/theme.ts
+++ b/packages/logic-grid-ai/src/theme.ts
@@ -129,6 +129,9 @@ 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.
 
diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
index bb2b46a..8d3eecf 100644
--- a/packages/logic-grid/src/axis.ts
+++ b/packages/logic-grid/src/axis.ts
@@ -4,8 +4,8 @@ import type { Category, Constraint, Grid, OrderedCategory } from "./types";
  * Return the list of `ordered: true` categories in declaration order.
  * These are the axes available to comparative constraints.
  */
-export function orderedCategories(grid: Grid): Category[] {
-  return grid.categories.filter((c) => c.ordered === true);
+export function orderedCategories(grid: Grid): OrderedCategory[] {
+  return grid.categories.filter((c) => c.ordered === true) as OrderedCategory[];
 }
 
 /**
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index f65431e..428d505 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -5,7 +5,6 @@ import type {
   Grid,
   OrderingComparatorType,
 } from "../types";
-// posNoun/posNounPlural no longer used — all rendering comes from axis comparators.
 import { orderedCategories, resolveAxis } from "../axis";
 
 function findCategory(value: string, grid: Grid): Category {
@@ -202,9 +201,6 @@ function renderText(constraint: Constraint, grid: Grid): string {
     }
     case "at_position": {
       // Render using the first ordered category's value at this position.
-      // The ordered value is always the object (position-like) side: we use
-      // its verb to produce "Alice lives in the first house" (House's verb),
-      // not "The first house plays piano" (Instrument's verb).
       const axis = orderedCategories(grid)[0];
       if (!axis) throw new Error("Grid has no ordered category");
       const axisVal = axis.values[constraint.position];

From 2fbb0d534af42af71d7d453e52c85f64e82534fb Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 17:45:21 +0200
Subject: [PATCH 13/24] docs: fix Grid type in README (remove stale
 positionNoun/spatialWords)

---
 packages/logic-grid/README.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/packages/logic-grid/README.md b/packages/logic-grid/README.md
index 4361f52..ce7caca 100644
--- a/packages/logic-grid/README.md
+++ b/packages/logic-grid/README.md
@@ -260,10 +260,7 @@ type Difficulty = "easy" | "medium" | "hard" | "expert";
 interface Grid {
   size: number;
   categories: Category[];
-  positionNoun: [string, string];
-  positionPreposition: string;
-  spatialWords: SpatialWords;
-  displayAxis?: string;
+  displayAxis?: string; // presentation hint: which ordered category for column headers
 }
 
 type Category = CategoryCore & OrderednessFields & ValueSuffixFields;
@@ -276,7 +273,7 @@ interface CategoryCore {
   verb?: [string, string];
   subjectPriority?: number;
 }
-// ordered: true enables numericValues and orderingPhrases.
+// ordered: true requires orderingPhrases with all 7 comparators.
 // valueSuffix enables positionAdjective.
 
 type Solution = Assignment[]; // one per category

From 3cbb517611a2653db41cba40829899d6454de6f2 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 18:13:33 +0200
Subject: [PATCH 14/24] feat: add displayLabels for grid column headers

Add optional displayLabels to ordered categories. When present, the
demo uses these for column headers instead of values. Clue rendering
always uses values.

Default House category gets displayLabels: ["1", "2", "3", ...] so
the grid shows house numbers while clues say "the first house".
Other presets (Hedge Fund) show their actual values (1972, 1983...).

Also fix displayAxisCategory return type to OrderedCategory.
---
 packages/demo/src/lib/PuzzleGrid.svelte   | 2 +-
 packages/logic-grid/src/axis.ts           | 2 +-
 packages/logic-grid/src/default-config.ts | 1 +
 packages/logic-grid/src/generator.ts      | 1 +
 packages/logic-grid/src/types.ts          | 3 +++
 5 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/packages/demo/src/lib/PuzzleGrid.svelte b/packages/demo/src/lib/PuzzleGrid.svelte
index 56f4105..99ed943 100644
--- a/packages/demo/src/lib/PuzzleGrid.svelte
+++ b/packages/demo/src/lib/PuzzleGrid.svelte
@@ -102,7 +102,7 @@
         <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/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
index 8d3eecf..8850721 100644
--- a/packages/logic-grid/src/axis.ts
+++ b/packages/logic-grid/src/axis.ts
@@ -49,7 +49,7 @@ export function axisRank(category: Category, value: string): number {
  * `grid.displayAxis` when set; otherwise returns the first ordered category.
  * Throws if no ordered category exists.
  */
-export function displayAxisCategory(grid: Grid): Category {
+export function displayAxisCategory(grid: Grid): OrderedCategory {
   if (grid.displayAxis !== undefined) {
     return resolveAxis(grid, grid.displayAxis);
   }
diff --git a/packages/logic-grid/src/default-config.ts b/packages/logic-grid/src/default-config.ts
index 962c0f2..fd489f8 100644
--- a/packages/logic-grid/src/default-config.ts
+++ b/packages/logic-grid/src/default-config.ts
@@ -138,6 +138,7 @@ export function defaultHouseCategory(size: number): Category {
     valueSuffix: "house",
     ordered: true,
     values: ordinals.slice(0, size),
+    displayLabels: Array.from({ length: size }, (_, i) => String(i + 1)),
     orderingPhrases: {
       unit: ["house", "houses"],
       comparators: {
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index 35d5ba0..d118bc6 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -215,6 +215,7 @@ function sliceCategory(c: Category, size: number): Category {
       ordered: true,
       numericValues: c.numericValues?.slice(0, size),
       orderingPhrases: c.orderingPhrases,
+      displayLabels: c.displayLabels?.slice(0, size),
       ...withSuffix,
     } as Category;
   }
diff --git a/packages/logic-grid/src/types.ts b/packages/logic-grid/src/types.ts
index 0bbaf90..8a0bf5b 100644
--- a/packages/logic-grid/src/types.ts
+++ b/packages/logic-grid/src/types.ts
@@ -55,6 +55,8 @@ type OrderednessFields =
       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;
@@ -88,6 +90,7 @@ export type OrderedCategory = CategoryCore & {
   ordered: true;
   numericValues?: number[];
   orderingPhrases: OrderingPhrases;
+  displayLabels?: string[];
 } & ValueSuffixFields;
 
 /** The puzzle board: `size` positions and one or more categories. */

From 132602c2173645ef0b2f8031b6d29da798aafb26 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 18:23:04 +0200
Subject: [PATCH 15/24] fix: stale comment in templates.ts, update
 logic-grid-ai README

---
 packages/logic-grid-ai/README.md           | 18 ++++++------------
 packages/logic-grid/src/clues/templates.ts |  5 +----
 2 files changed, 7 insertions(+), 16 deletions(-)

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/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 428d505..c59efb8 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -28,10 +28,7 @@ function objectValue(value: string, grid: Grid): string {
   return suffix ? `${value.toLowerCase()} ${suffix}` : value.toLowerCase();
 }
 
-/**
- * Look up a comparator phrase. Checks the axis category's orderingPhrases
- * first, then falls back to grid-level spatialWords.comparators.
- */
+/** Look up a comparator phrase from the axis category's orderingPhrases. */
 function comparator(
   grid: Grid,
   type: OrderingComparatorType,

From 391bbb90a9e6759234218831776bc6248363e361 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 19:09:06 +0200
Subject: [PATCH 16/24] fix: address review feedback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add complexity comment on encodeBetweenAxis (O(M³·n³), acceptable
  for grid sizes 3-8)
- Cap next_to constraint count in per-axis enumeration (was uncapped,
  could produce disproportionately many constraints with multiple axes)
- Add doc comment on orderedCategories (never throws, returns empty)
- Clean up stale phase comments — describe current behavior, not
  historical phases
- Add comment explaining displayLabels vs values on House category
- Add multi-axis generator test exercising both encoder paths
---
 packages/demo/src/lib/PuzzleGrid.svelte       |  4 +--
 packages/demo/src/lib/puzzle-state.svelte.ts  |  2 +-
 .../src/__snapshots__/index.test.ts.snap      | 17 +++++-----
 packages/logic-grid/src/axis.ts               |  1 +
 packages/logic-grid/src/default-config.ts     |  1 +
 packages/logic-grid/src/encoding.ts           | 11 ++++---
 packages/logic-grid/src/generator.test.ts     | 33 +++++++++++++++----
 packages/logic-grid/src/generator.ts          | 18 +++++-----
 8 files changed, 55 insertions(+), 32 deletions(-)

diff --git a/packages/demo/src/lib/PuzzleGrid.svelte b/packages/demo/src/lib/PuzzleGrid.svelte
index 99ed943..751f23a 100644
--- a/packages/demo/src/lib/PuzzleGrid.svelte
+++ b/packages/demo/src/lib/PuzzleGrid.svelte
@@ -16,8 +16,8 @@
     onEliminate: (valueIdx: number, position: number) => void;
   } = $props();
 
-  // The display-axis category provides column headers. Phase 1 identity-pins
-  // it, so its values are excluded from the mystery rows.
+  // 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 display-axis category). */
diff --git a/packages/demo/src/lib/puzzle-state.svelte.ts b/packages/demo/src/lib/puzzle-state.svelte.ts
index 4fe2ad3..f396bf1 100644
--- a/packages/demo/src/lib/puzzle-state.svelte.ts
+++ b/packages/demo/src/lib/puzzle-state.svelte.ts
@@ -121,7 +121,7 @@ export function createPuzzleState() {
         grid = Array.from({ length: totalValues }, () =>
           Array.from({ length: puzzle!.grid.size }, () => "empty" as CellState),
         );
-        // Pre-confirm the display-axis category (identity assignment in Phase 1)
+        // 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++) {
diff --git a/packages/logic-grid/src/__snapshots__/index.test.ts.snap b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
index 07a4002..dd96ecc 100644
--- a/packages/logic-grid/src/__snapshots__/index.test.ts.snap
+++ b/packages/logic-grid/src/__snapshots__/index.test.ts.snap
@@ -2,16 +2,15 @@
 
 exports[`public API integration > generate with custom noun/verb produces correct clues 1`] = `
 [
+  "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.",
-  "The german speaker plays the violin.",
-  "Luna does not live somewhere between the piano player and the rose grower.",
-  "The german speaker lives next to the drums player.",
-  "Theo lives next to the guitar player.",
-  "The lily grower plays the violin.",
-  "The third house grows the rose.",
-  "The first house does not grow the tulip.",
-  "The piano player lives in the first house.",
-  "The first house speaks italian.",
+  "Luna lives directly right of the drums player.",
   "The french speaker lives in the third house.",
 ]
 `;
diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
index 8850721..f925036 100644
--- a/packages/logic-grid/src/axis.ts
+++ b/packages/logic-grid/src/axis.ts
@@ -3,6 +3,7 @@ import type { Category, Constraint, Grid, OrderedCategory } from "./types";
 /**
  * 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((c) => c.ordered === true) as OrderedCategory[];
diff --git a/packages/logic-grid/src/default-config.ts b/packages/logic-grid/src/default-config.ts
index fd489f8..934e809 100644
--- a/packages/logic-grid/src/default-config.ts
+++ b/packages/logic-grid/src/default-config.ts
@@ -138,6 +138,7 @@ export function defaultHouseCategory(size: number): Category {
     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"],
diff --git a/packages/logic-grid/src/encoding.ts b/packages/logic-grid/src/encoding.ts
index c603fc7..085c3f9 100644
--- a/packages/logic-grid/src/encoding.ts
+++ b/packages/logic-grid/src/encoding.ts
@@ -2,10 +2,9 @@ import type { Category, Constraint, Grid } from "./types";
 import { resolveAxis } from "./axis";
 
 /**
- * True when `axis` is the first ordered category in `grid`. Phase 1/2 pins
- * this category by identity in encodeBase, so rank = position for it; we can
- * use the cheap positional encoders for any comparative constraint targeting
- * this 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;
@@ -108,6 +107,10 @@ function encodeBinaryAxis(
  * (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,
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index 1ce92bf..5fbdb77 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -538,7 +538,7 @@ describe("generate", () => {
 
     expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
 
-    // Phase 1: exact_distance constraints are emitted for value pairs whose
+    // 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];
@@ -554,7 +554,7 @@ describe("generate", () => {
     }
   });
 
-  it("first ordered category gets identity assignment (Phase 1)", () => {
+  it("first ordered category gets identity assignment", () => {
     const puzzle = generate({
       size: 4,
       seed: 42,
@@ -581,7 +581,7 @@ describe("generate", () => {
       ],
     });
 
-    // First ordered category (Return) gets identity mapping in Phase 1.
+    // 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);
@@ -697,10 +697,9 @@ describe("generate with multiple ordered categories", () => {
   });
 
   it("multi-axis puzzles still round-trip through the SAT solver", () => {
-    // Phase 3 only guarantees SAT-level uniqueness. Phase 4 adds rank-space
-    // deduction for non-first ordered axes; until then `deduce()` may stall
-    // on constraints targeting a non-pinned axis. The solver, however, must
-    // reproduce the exact solution.
+    // 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,
@@ -714,4 +713,24 @@ describe("generate with multiple ordered categories", () => {
       }
     }
   });
+
+  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 d118bc6..451ef8c 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -223,10 +223,9 @@ function sliceCategory(c: Category, size: number): Category {
 }
 
 function randomSolution(grid: Grid, rng: () => number): Solution {
-  // Phase 1: identity-assign the first ordered category so row = axis rank for
-  // it. This keeps the still-row-based encoder semantically consistent with
-  // the axis-tagged comparatives the generator emits. Phase 2 switches the
-  // encoder to rank-forbidding and removes identity assignment.
+  // 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) {
@@ -305,6 +304,7 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
     }
     const numVals = axis.numericValues;
 
+    let nextCount = 0;
     let notNextCount = 0;
     for (let i = 0; i < allValues.length; i++) {
       if (catArr[i] === axisCatIdx) continue;
@@ -317,8 +317,9 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
         const b = allValues[j];
         const rankB = rankAtRow[posArr[j]];
 
-        if (Math.abs(rankA - rankB) === 1) {
+        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++;
@@ -428,8 +429,7 @@ function enumerateConstraints(solution: Solution, grid: Grid): Constraint[] {
 
   // --- Position constraints ---
   // Skip values in the first ordered category — identity pinning makes their
-  // rows trivially determined by encodeBase. Phase 4 removes identity pinning
-  // and broadens this skip rule.
+  // rows trivially determined by encodeBase's identity pinning.
   const firstOrdered = orderedCats[0];
   const firstOrderedValues = new Set(firstOrdered.values);
   for (const [val, pos] of posOf) {
@@ -546,7 +546,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);
 
@@ -575,7 +575,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);

From f41620062dc58639308bdeb3cab7207b6a951ab9 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 19:27:24 +0200
Subject: [PATCH 17/24] fix: second round of review feedback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Clean up ${"in"}/${"position"} template noise in deduction
  explanations — use plain string interpolation
- Add isOrdered type predicate, use in orderedCategories and
  resolveAxis instead of as-casts
- Remove redundant resolveAxis call in tryExactDistance
- Remove TEST_COMPARATORS duplication — generator.test.ts imports
  from test-helpers.ts
- Export isOrdered from index.ts
---
 packages/logic-grid/src/axis.ts               | 11 ++++++++---
 packages/logic-grid/src/deduce/constraints.ts | 11 +++++------
 packages/logic-grid/src/deduce/structural.ts  | 12 ++++++------
 packages/logic-grid/src/generator.test.ts     | 14 ++------------
 packages/logic-grid/src/generator.ts          |  6 +++---
 packages/logic-grid/src/index.ts              |  1 +
 6 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
index f925036..6ffafb9 100644
--- a/packages/logic-grid/src/axis.ts
+++ b/packages/logic-grid/src/axis.ts
@@ -1,12 +1,17 @@
 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((c) => c.ordered === true) as OrderedCategory[];
+  return grid.categories.filter(isOrdered);
 }
 
 /**
@@ -18,12 +23,12 @@ export function resolveAxis(grid: Grid, axisName: string): OrderedCategory {
   if (!cat) {
     throw new RangeError(`Unknown axis: "${axisName}"`);
   }
-  if (cat.ordered !== true) {
+  if (!isOrdered(cat)) {
     throw new RangeError(
       `Axis "${axisName}" must reference an ordered category`,
     );
   }
-  return cat as OrderedCategory;
+  return cat;
 }
 
 /**
diff --git a/packages/logic-grid/src/deduce/constraints.ts b/packages/logic-grid/src/deduce/constraints.ts
index 5772a15..e1b30df 100644
--- a/packages/logic-grid/src/deduce/constraints.ts
+++ b/packages/logic-grid/src/deduce/constraints.ts
@@ -154,7 +154,7 @@ function tryAtPosition(
     [ci],
     elims,
     [{ value: c.value, position: c.position }],
-    `Clue ${ci + 1}: ${c.value} must be ${"in"} the ${ordinal(c.position)} ${"position"}.`,
+    `Clue ${ci + 1}: ${c.value} must be in the ${ordinal(c.position)} position.`,
   );
 }
 
@@ -171,14 +171,14 @@ function tryNotAtPosition(
     ps.size === 1 ? [{ value: c.value, position: first(ps) }] : [];
   const suffix =
     assigns.length > 0
-      ? `, so ${c.value} must be ${"in"} the ${ordinal(assigns[0].position)} ${"position"}.`
+      ? `, 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 ${"in"} the ${ordinal(c.position)} ${"position"}${suffix}`,
+    `Clue ${ci + 1}: ${c.value} is not in the ${ordinal(c.position)} position${suffix}`,
   );
 }
 
@@ -265,7 +265,7 @@ function tryNotSamePosition(
     [ci],
     elims,
     assigns,
-    `${clueRef(ci)}${pinned} and ${other} are ${prep} different ${"positions"}. ${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}`,
   );
 }
 
@@ -848,8 +848,7 @@ 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 axisForUnit = resolveAxis(state.grid, c.axis);
-  const unit = axisForUnit.orderingPhrases?.unit;
+  const unit = axis.orderingPhrases.unit;
   const distLabel = unit
     ? `${c.distance} ${c.distance === 1 ? unit[0] : unit[1]}`
     : `${c.distance} ${c.distance === 1 ? "position" : "positions"}`;
diff --git a/packages/logic-grid/src/deduce/structural.ts b/packages/logic-grid/src/deduce/structural.ts
index d5714b7..2c64839 100644
--- a/packages/logic-grid/src/deduce/structural.ts
+++ b/packages/logic-grid/src/deduce/structural.ts
@@ -43,7 +43,7 @@ export function tryNakedSingles(state: DeduceState): DeductionStep | null {
         [],
         elims,
         assigns,
-        `${cat.values[vi]} has no other possible position — it must be ${"in"} the ${ordinal(pos)} ${"position"}. 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)} ${"position"} 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 ${"in"} the ${positions} ${"positions"}, 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 ${"in"} the ${positions} ${"positions"}, 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)} ${"positions"}, 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)} ${"positions"}, 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/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index 5fbdb77..a09ce2c 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -3,18 +3,8 @@ import { generate } from "./generator";
 import { deduce } from "./deduce";
 import { hasUniqueSolution, solve } from "./solver";
 import { resolveAxis } from "./axis";
-import type { Category, ComparatorMap, Grid } from "./types";
-
-/** Generic comparators for test ordered categories. */
-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",
-};
+import { TEST_COMPARATORS } from "./test-helpers";
+import type { Category, Grid } from "./types";
 
 describe("generate", () => {
   it("returns a valid puzzle with defaults", () => {
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index 451ef8c..d355b1b 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -16,7 +16,7 @@ import { IncrementalSolver } from "./sat";
 import { renderClue } from "./clues/templates";
 import { classify, EASY_TYPES, MEDIUM_TYPES } from "./difficulty";
 import { deduce } from "./deduce";
-import { orderedCategories, resolveAxis } from "./axis";
+import { isOrdered, orderedCategories, resolveAxis } from "./axis";
 import { DEFAULT_CATEGORIES, defaultHouseCategory } from "./default-config";
 
 const MAX_RETRIES = 100;
@@ -209,7 +209,7 @@ function sliceCategory(c: Category, size: number): Category {
     c.valueSuffix !== undefined
       ? { valueSuffix: c.valueSuffix, positionAdjective: c.positionAdjective }
       : {};
-  if (c.ordered === true) {
+  if (isOrdered(c)) {
     return {
       ...base,
       ordered: true,
@@ -217,7 +217,7 @@ function sliceCategory(c: Category, size: number): Category {
       orderingPhrases: c.orderingPhrases,
       displayLabels: c.displayLabels?.slice(0, size),
       ...withSuffix,
-    } as Category;
+    } as Category; // spread loses union discrimination
   }
   return { ...base, ...withSuffix } as Category;
 }
diff --git a/packages/logic-grid/src/index.ts b/packages/logic-grid/src/index.ts
index f229517..325111f 100644
--- a/packages/logic-grid/src/index.ts
+++ b/packages/logic-grid/src/index.ts
@@ -20,6 +20,7 @@ export {
 
 export { renderClue } from "./clues/templates";
 export {
+  isOrdered,
   resolveAxis,
   orderedCategories,
   axisRank,

From 19554caa31197c90cc6adb1a3bbb14d2d659f1b4 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 19:45:15 +0200
Subject: [PATCH 18/24] refactor: require verb on ordered categories via type
 system

Move verb from CategoryCore (optional) into the OrderednessFields
discriminated union: required on ordered: true, optional on unordered.
This makes it a compile-time error to construct an ordered category
without a verb, eliminating the runtime throw in templates.ts.

Remove the now-unnecessary runtime checks and their tests.
---
 .../logic-grid/src/clues/templates.test.ts    | 45 ++-----------------
 packages/logic-grid/src/clues/templates.ts    |  4 --
 packages/logic-grid/src/generator.ts          |  2 +-
 packages/logic-grid/src/types.ts              |  8 +++-
 4 files changed, 10 insertions(+), 49 deletions(-)

diff --git a/packages/logic-grid/src/clues/templates.test.ts b/packages/logic-grid/src/clues/templates.test.ts
index 3ba8206..208e250 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { renderClue } from "./templates";
-import { makeGrid, TEST_COMPARATORS } from "../test-helpers";
+import { makeGrid } from "../test-helpers";
 import type { Grid } from "../types";
 
 const grid = makeGrid({
@@ -600,45 +600,6 @@ describe("at_position / not_at_position invariants", () => {
     ).toThrow("no ordered category");
   });
 
-  it("at_position throws when ordered category has no verb", () => {
-    const noVerbGrid: Grid = {
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-        {
-          name: "Axis",
-          values: ["X", "Y", "Z"],
-          ordered: true,
-          orderingPhrases: { comparators: TEST_COMPARATORS },
-        },
-      ],
-    };
-    expect(() =>
-      renderClue(
-        { type: "at_position", value: "Alice", position: 0 },
-        noVerbGrid,
-      ),
-    ).toThrow("has no verb");
-  });
-
-  it("not_at_position throws when ordered category has no verb", () => {
-    const noVerbGrid: Grid = {
-      size: 3,
-      categories: [
-        { name: "Name", values: ["Alice", "Bob", "Carol"], noun: "" },
-        {
-          name: "Axis",
-          values: ["X", "Y", "Z"],
-          ordered: true,
-          orderingPhrases: { comparators: TEST_COMPARATORS },
-        },
-      ],
-    };
-    expect(() =>
-      renderClue(
-        { type: "not_at_position", value: "Alice", position: 0 },
-        noVerbGrid,
-      ),
-    ).toThrow("has no verb");
-  });
+  // "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 c59efb8..7c0e0f7 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -205,8 +205,6 @@ function renderText(constraint: Constraint, grid: Grid): string {
       if (cat.positionAdjective) {
         return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[0]} ${constraint.value.toLowerCase()}.`;
       }
-      if (!axis.verb)
-        throw new Error(`Ordered category "${axis.name}" has no verb`);
       return `${capitalize(label(constraint.value, grid))} ${axis.verb[0]} ${objectValue(axisVal, grid)}.`;
     }
     case "not_at_position": {
@@ -217,8 +215,6 @@ function renderText(constraint: Constraint, grid: Grid): string {
       if (cat.positionAdjective) {
         return `${capitalize(label(axisVal, grid))} ${cat.positionAdjective[1]} ${constraint.value.toLowerCase()}.`;
       }
-      if (!axis.verb)
-        throw new Error(`Ordered category "${axis.name}" has no verb`);
       return `${capitalize(label(constraint.value, grid))} ${axis.verb[1]} ${objectValue(axisVal, grid)}.`;
     }
   }
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index d355b1b..492862a 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -60,7 +60,7 @@ function validateCategories(categories: Category[]): void {
       );
     }
 
-    if (c.ordered === true) {
+    if (isOrdered(c)) {
       if (c.numericValues !== undefined) {
         if (c.numericValues.length !== c.values.length) {
           throw new RangeError(
diff --git a/packages/logic-grid/src/types.ts b/packages/logic-grid/src/types.ts
index 8a0bf5b..531f601 100644
--- a/packages/logic-grid/src/types.ts
+++ b/packages/logic-grid/src/types.ts
@@ -33,8 +33,6 @@ interface CategoryCore {
   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]`. Required when noun !== "". */
-  verb?: [string, string];
   /** Subject priority for same-position clues. Higher = more likely to be the sentence subject. */
   subjectPriority?: number;
 }
@@ -45,12 +43,15 @@ interface CategoryCore {
  * `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. */
@@ -60,6 +61,8 @@ type OrderednessFields =
     }
   | {
       ordered?: false;
+      /** Verb phrases for same-position clues: `[positive, negative]`. Required when noun !== "" (runtime check). */
+      verb?: [string, string];
       numericValues?: never;
       orderingPhrases?: never;
     };
@@ -88,6 +91,7 @@ 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[];

From fa54d83066c54627aad99e24601ff9e84aeb771f Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 20:07:28 +0200
Subject: [PATCH 19/24] refactor: enforce comparator shapes via type system
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ComparatorMap is now an interface with precise types per key:
- before, left_of: [string, string] (directional, tuple required)
- next_to, not_next_to, between, not_between, exact_distance: string
  (symmetric, plain string only)

This eliminates the runtime checkComparators validation in the
generator — the type system catches symmetric-tuple errors at compile
time. The AI validation layer keeps its runtime check since AI JSON
output is untyped.

Remove ComparatorPhrase type (unused). Simplify directionalComp
(always receives a tuple). Remove SYMMETRIC_COMPARATORS set and
checkComparators function from generator.
---
 packages/logic-grid-ai/src/validation.ts      |  5 +-
 .../logic-grid/src/clues/templates.test.ts    |  8 ++--
 packages/logic-grid/src/clues/templates.ts    | 46 ++++++-------------
 packages/logic-grid/src/generator.test.ts     | 32 ++-----------
 packages/logic-grid/src/generator.ts          | 23 ----------
 packages/logic-grid/src/index.ts              |  1 -
 packages/logic-grid/src/types.ts              | 27 +++++++----
 7 files changed, 43 insertions(+), 99 deletions(-)

diff --git a/packages/logic-grid-ai/src/validation.ts b/packages/logic-grid-ai/src/validation.ts
index 6fb6e05..3302845 100644
--- a/packages/logic-grid-ai/src/validation.ts
+++ b/packages/logic-grid-ai/src/validation.ts
@@ -38,7 +38,7 @@ const POSITIONAL_WORDS = new Set([
  * (generateTheme) casts to ThemeResult only after validation passes.
  */
 export function validateThemeResult(
-  result: { categories: RawCategory[] },
+  result: { categories: readonly unknown[] },
   expectedSize: number,
   expectedCategories: number,
 ): string[] {
@@ -56,7 +56,8 @@ export function validateThemeResult(
   let personCount = 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
diff --git a/packages/logic-grid/src/clues/templates.test.ts b/packages/logic-grid/src/clues/templates.test.ts
index 208e250..e4da40d 100644
--- a/packages/logic-grid/src/clues/templates.test.ts
+++ b/packages/logic-grid/src/clues/templates.test.ts
@@ -317,8 +317,8 @@ describe("per-axis comparator overrides on House", () => {
         values: ["first", "second", "third"],
         orderingPhrases: {
           comparators: {
-            before: "comes earlier than",
-            left_of: "is directly before",
+            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",
@@ -348,7 +348,7 @@ describe("per-axis comparator overrides on House", () => {
       { type: "left_of", a: "Alice", b: "Bob", axis: "House" },
       withComparators,
     );
-    expect(clue.text).toBe("Alice is directly before Bob.");
+    expect(clue.text).toBe("Bob is directly after Alice.");
   });
 
   it("before uses grid comparator when set", () => {
@@ -356,7 +356,7 @@ describe("per-axis comparator overrides on House", () => {
       { type: "before", a: "Alice", b: "Bob", axis: "House" },
       withComparators,
     );
-    expect(clue.text).toBe("Alice comes earlier than Bob.");
+    expect(clue.text).toBe("Bob comes later than Alice.");
   });
 
   it("next_to uses grid comparator when set", () => {
diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 7c0e0f7..78a43bc 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -1,10 +1,4 @@
-import type {
-  Category,
-  Constraint,
-  Clue,
-  Grid,
-  OrderingComparatorType,
-} from "../types";
+import type { Category, Constraint, Clue, Grid } from "../types";
 import { orderedCategories, resolveAxis } from "../axis";
 
 function findCategory(value: string, grid: Grid): Category {
@@ -28,45 +22,33 @@ function objectValue(value: string, grid: Grid): string {
   return suffix ? `${value.toLowerCase()} ${suffix}` : value.toLowerCase();
 }
 
-/** Look up a comparator phrase from the axis category's orderingPhrases. */
-function comparator(
-  grid: Grid,
-  type: OrderingComparatorType,
-  axisName: string,
-): string | [string, string] {
-  const axis = resolveAxis(grid, axisName);
-  return axis.orderingPhrases.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,
+  type:
+    | "next_to"
+    | "not_next_to"
+    | "between"
+    | "not_between"
+    | "exact_distance",
   axisName: string,
 ): string {
-  return comparator(grid, type, axisName) as 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,
   axisName: string,
 ): { subject: string; object: string; phrase: string } {
-  const c = comparator(grid, type, axisName);
-  if (typeof c === "string") {
-    return { subject: a, object: b, phrase: c };
-  }
+  const c = resolveAxis(grid, axisName).orderingPhrases.comparators[type];
   const [s] = ordered(a, b, grid);
   return s === a
     ? { subject: a, object: b, phrase: c[0] }
diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index a09ce2c..d4ed414 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -448,35 +448,9 @@ describe("generate", () => {
     ).toThrow("requires a verb");
   });
 
-  it("throws when symmetric comparator is a tuple", () => {
-    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"],
-            ordered: true,
-            orderingPhrases: {
-              comparators: {
-                ...TEST_COMPARATORS,
-                next_to: ["fwd", "rev"] as [string, string],
-              },
-            },
-          },
-          {
-            name: "Activity",
-            values: ["Yoga", "Cardio", "Run"],
-            noun: "doer",
-            verb: ["does", "does not do"],
-          },
-        ],
-      }),
-    ).toThrow('comparator "next_to" is symmetric');
-  });
+  // "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(() =>
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index 492862a..f851d27 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,
@@ -21,27 +20,6 @@ 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): void {
-  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 the grid is
  * used for anything, so downstream code can rely on these invariants.
@@ -75,7 +53,6 @@ function validateCategories(categories: Category[]): void {
           }
         }
       }
-      checkComparators(`Category "${c.name}"`, c.orderingPhrases.comparators);
     }
   }
 }
diff --git a/packages/logic-grid/src/index.ts b/packages/logic-grid/src/index.ts
index 325111f..8da199c 100644
--- a/packages/logic-grid/src/index.ts
+++ b/packages/logic-grid/src/index.ts
@@ -32,7 +32,6 @@ export type {
   Category,
   OrderingPhrases,
   OrderingComparatorType,
-  ComparatorPhrase,
   ComparatorMap,
   Grid,
   Assignment,
diff --git a/packages/logic-grid/src/types.ts b/packages/logic-grid/src/types.ts
index 531f601..c9137bb 100644
--- a/packages/logic-grid/src/types.ts
+++ b/packages/logic-grid/src/types.ts
@@ -9,15 +9,26 @@ 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. All 7 keys required. */
-export type ComparatorMap = 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 {

From cf091bfcba129d60e24513e951c2fdd62f2a5d9d Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 20:19:52 +0200
Subject: [PATCH 20/24] fix: use 'in' guard instead of unsafe cast in
 validateConstraints

---
 packages/logic-grid/src/axis.ts | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/packages/logic-grid/src/axis.ts b/packages/logic-grid/src/axis.ts
index 6ffafb9..56d1bb6 100644
--- a/packages/logic-grid/src/axis.ts
+++ b/packages/logic-grid/src/axis.ts
@@ -66,17 +66,6 @@ export function displayAxisCategory(grid: Grid): OrderedCategory {
   return first;
 }
 
-/** Constraint types that carry an `axis` field. */
-const AXIS_CONSTRAINT_TYPES = new Set([
-  "next_to",
-  "not_next_to",
-  "left_of",
-  "between",
-  "not_between",
-  "before",
-  "exact_distance",
-]);
-
 /**
  * Validate that every comparative constraint in `constraints` references an
  * ordered category that exists in the grid. Throws on the first violation.
@@ -86,9 +75,8 @@ export function validateConstraints(
   grid: Grid,
 ): void {
   for (const c of constraints) {
-    if (AXIS_CONSTRAINT_TYPES.has(c.type)) {
-      const axisName = (c as { axis: string }).axis;
-      resolveAxis(grid, axisName);
+    if ("axis" in c && typeof c.axis === "string") {
+      resolveAxis(grid, c.axis);
     }
   }
 }

From 35ed332ea40edacdb4b708c681792fdb0e9e1eb3 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 20:22:26 +0200
Subject: [PATCH 21/24] cleanup: remove unnecessary as [string, string] casts
 in demo presets

---
 packages/demo/src/routes/+page.svelte | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/packages/demo/src/routes/+page.svelte b/packages/demo/src/routes/+page.svelte
index 59afdc6..b1a3c97 100644
--- a/packages/demo/src/routes/+page.svelte
+++ b/packages/demo/src/routes/+page.svelte
@@ -27,13 +27,13 @@
           ordered: true,
           numericValues: [3, 5, 8, 12],
           orderingPhrases: {
-            unit: ["percentage point", "percentage points"] as [string, string],
+            unit: ["percentage point", "percentage points"],
             comparators: {
-              before: ["has a lower return than", "has a higher return than"] as [string, string],
+              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",
-              ] 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 somewhere between",
@@ -60,16 +60,16 @@
           ordered: true,
           numericValues: [7, 8, 9, 10],
           orderingPhrases: {
-            unit: ["hour", "hours"] as [string, string],
+            unit: ["hour", "hours"],
             comparators: {
               before: [
                 "has an earlier appointment than",
                 "has a later appointment than",
-              ] as [string, string],
+              ],
               left_of: [
                 "has the appointment right before",
                 "has the appointment right after",
-              ] as [string, string],
+              ],
               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",
@@ -96,10 +96,10 @@
           ordered: true,
           numericValues: [1972, 1983, 1997, 2005],
           orderingPhrases: {
-            unit: ["year", "years"] as [string, string],
+            unit: ["year", "years"],
             comparators: {
-              before: ["started earlier than", "started later than"] as [string, string],
-              left_of: ["started right before", "started right after"] as [string, string],
+              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",
@@ -116,10 +116,10 @@
           subjectPriority: -1,
           ordered: true,
           orderingPhrases: {
-            unit: ["percentage point", "percentage points"] as [string, string],
+            unit: ["percentage point", "percentage points"],
             comparators: {
-              before: ["has a lower return than", "has a higher return than"] as [string, string],
-              left_of: ["has the next lower return than", "has the next higher return than"] as [string, string],
+              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",

From be1c4b7300a8bf4f932071010acf5bb886cec187 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 20:24:17 +0200
Subject: [PATCH 22/24] docs: comment explaining at_position vs displayAxis
 distinction

---
 packages/logic-grid/src/clues/templates.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/logic-grid/src/clues/templates.ts b/packages/logic-grid/src/clues/templates.ts
index 78a43bc..b1c8328 100644
--- a/packages/logic-grid/src/clues/templates.ts
+++ b/packages/logic-grid/src/clues/templates.ts
@@ -179,7 +179,9 @@ function renderText(constraint: Constraint, grid: Grid): string {
       return `${capitalize(la)} ${prefix} ${constraint.distance} from ${lb}.`;
     }
     case "at_position": {
-      // Render using the first ordered category's value at this 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];

From 45b1da688077aa8f7f5a2941e9b9f1db9aea32d3 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 20:32:07 +0200
Subject: [PATCH 23/24] fix: reject empty constraint sets in generator, seed
 flaky tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The generator could return a puzzle with 0 constraints when the
minimizer couldn't achieve uniqueness — observed on CI with
Math.random. Now it retries on empty constraint sets.

Seed 4 previously-unseeded generate() calls to prevent
platform-dependent flakiness.
---
 packages/logic-grid/src/generator.test.ts | 8 ++++----
 packages/logic-grid/src/generator.ts      | 6 ++++++
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/packages/logic-grid/src/generator.test.ts b/packages/logic-grid/src/generator.test.ts
index d4ed414..f997780 100644
--- a/packages/logic-grid/src/generator.test.ts
+++ b/packages/logic-grid/src/generator.test.ts
@@ -8,7 +8,7 @@ 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);
@@ -19,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);
@@ -33,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)) {
@@ -126,7 +126,7 @@ describe("generate", () => {
   });
 
   it("puzzle has a unique solution", () => {
-    const puzzle = generate();
+    const puzzle = generate({ seed: 4 });
     expect(hasUniqueSolution(puzzle.constraints, puzzle.grid)).toBe(true);
   });
 
diff --git a/packages/logic-grid/src/generator.ts b/packages/logic-grid/src/generator.ts
index f851d27..a9b932e 100644
--- a/packages/logic-grid/src/generator.ts
+++ b/packages/logic-grid/src/generator.ts
@@ -97,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

From 1a57171a7050b6dcc0856dbcba2ef066b0d60c95 Mon Sep 17 00:00:00 2001
From: Anton Stefer <59652072+antonstefer@users.noreply.github.com>
Date: Fri, 10 Apr 2026 20:41:17 +0200
Subject: [PATCH 24/24] =?UTF-8?q?fix(ai):=20correct=20prompt=20=E2=80=94?=
 =?UTF-8?q?=20comparators=20are=20required,=20not=20optional?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 packages/logic-grid-ai/src/theme.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/logic-grid-ai/src/theme.ts b/packages/logic-grid-ai/src/theme.ts
index 157c0c6..b1303a2 100644
--- a/packages/logic-grid-ai/src/theme.ts
+++ b/packages/logic-grid-ai/src/theme.ts
@@ -147,7 +147,7 @@ At least one category must have \`ordered: true\` so comparative constraints can
 
 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 OPTIONAL** — but without them, clues fall back to generic "lives next to" / "lives left of" phrasing that only works for spatial themes (houses, docks, seats). For any non-spatial ordered category (scores, times, prices, years), you MUST set comparators for at least: \`before\`, \`left_of\`, \`next_to\`, \`not_next_to\`.
+**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"]\`