arxo-fide-chess

![FIDE Laws of Chess on Arxo](npm/assets/cover.svg)

# FIDE Laws of Chess on Arxo

[![Smithery](https://smithery.ai/badge/arxohq/fide-chess)](https://smithery.ai/servers/arxohq/fide-chess)

**Explore a chess arbiter's decision through a pinned model, explicit facts and an inspectable answer.** Ten retained fictional cases cover illegal moves, flag fall, rapid/blitz exceptions, recording and arbiter judgment.

**Node.js 20+ · ESM · canon package 0.1.0 · model 0.1.1 · FIDE edition effective 1 January 2023**

[Start in Node.js](#start-in-nodejs) · [Cases](#choose-a-case) · [Evidence](#inspect-the-evidence) · [Depth](#formalization-depth) · [Submit a case](https://github.com/arxohq/arxo-fide-chess/issues/new) · [Source repository](https://github.com/arxohq/arxo-fide-chess)

This is an independent open-source teaching and research demonstration. For an actual chess ruling, use the authentic FIDE Laws and the competent arbiter. Source text and model scope are pinned; the package does not claim general chess-engine capability or complete formalization.

## Start in Node.js

Requirements: **Node.js 20+**. The example uses ES modules; keep the `.mjs`
extension. This recipe was checked on macOS arm64 with Node.js 20.20.2 on
14 October 2026. No global CLI, Git clone or MCP client is needed for this route.

Create a fresh directory, open a terminal there, then run:

```sh
npm init -y
npm install --ignore-scripts @arxo/canon-fide-chess@0.1.0 @arxo/law@0.4.3
```

Save this as `example.mjs`, then run `node example.mjs`:

```js
import { open } from '@arxo/law';
import { loadModel } from '@arxo/canon-fide-chess/chess';
import { game, white, getCaseInput } from '@arxo/canon-fide-chess/examples/arbiter';

const model = await loadModel();
const chess = await open(model.spec, {
  offline: true,
  local: { packages: { [model.spec]: model.package } },
});

const input = getCaseInput('SecondIllegal');
const loss = await chess.truth('game_lost_by', [game, white], input);
const draw = await chess.truth('game_drawn', [game], input);
console.log(loss.evaluationStatus, loss.truthStatus); // COMPUTED, TRUE_ONLY
console.log(draw.evaluationStatus, draw.truthStatus); // COMPUTED, NEITHER
```

The two output lines are **loss**, then **draw**:

```text
COMPUTED TRUE_ONLY
COMPUTED NEITHER
```

`COMPUTED` means the query was evaluated. `TRUE_ONLY` means it has positive
support and no negative support. `NEITHER` means neither polarity is supported;
it does not establish that the proposition is false.

Now replace only `getCaseInput('SecondIllegal')` with
`getCaseInput('SecondIllegalNoMate')` and run `node example.mjs` again:

```text
REQUIRES_JUDGMENT NEITHER
COMPUTED TRUE_ONLY
```

The second line now establishes a draw. This case supplies the fact that the
opponent cannot checkmate by any legal series. The separate loss query still
requests an arbiter's assessment because other reachable loss grounds remain
unresolved. Read both status fields; `REQUIRES_JUDGMENT` identifies an assessment
the model does not decide on its own.

To try another retained episode, choose a name from [the case table](#choose-a-case).
To propose your own episode, [open an issue](https://github.com/arxohq/arxo-fide-chess/issues/new)
with the case facts, legal date, query, package/runtime versions, output and the
FIDE clause or model rule you think should give a different answer. Use a
fictional or anonymized case.

The SDK executes the rules through `@arxo/law-engine@0.5.3`. Installation alone does not register this distribution in the SDK's automatic canon resolver: keep the explicit `local.packages` handoff above. The loader implements no chess decisions or formulas.

![Model and episode to answer and proof](npm/assets/model-to-answer.svg)

## Use as an MCP server

The separate native MCP wrapper runs the same pinned model over stdio:

```sh
npx -y @arxo/mcp-fide-chess@0.1.0
```

Node.js 20+, Linux x64 or macOS arm64. [Client configuration, HTTP endpoint, inputs and limitations](docs/mcp.md) · [OCI recipe](docs/mcp-release.md) · [npm recipe](docs/mcp-npm-release.md) · [Accepted delivery](docs/mcp-release.md#accepted-delivery--14-october-2026). This MCP delivery is separate from the Node.js route above.

## Choose a case

| `getCaseInput(name)` | Episode | Checked question and result |
|---|---|---|
| `TouchIntentUnknown` | A movable own piece; intentional touch not adjudicated | `must_move_first_touched_piece`: `REQUIRES_JUDGMENT / NEITHER` |
| `FirstIllegal` | One completed illegal move | Loss: `REQUIRES_JUDGMENT / NEITHER`; draw: `COMPUTED / NEITHER` |
| `SecondIllegal` | Two illegal moves under the model's specified closure | Loss: `COMPUTED / TRUE_ONLY` |
| `SecondIllegalNoMate` | Two illegal moves; inability to checkmate established | Draw: `COMPUTED / TRUE_ONLY` |
| `FlagFall` | Flag observed, time control not completed, mate possible | Loss: `COMPUTED / TRUE_ONLY` |
| `FlagFallNoMate` | The same flag; inability to checkmate established | Draw: `COMPUTED / TRUE_ONLY` |
| `RapidFirstIllegal` | Rapid 15+10; first illegal move | Opponent receives 60 seconds; 120-second query is `NEITHER` |
| `BlitzFirstIllegalCompetitive` | Blitz 3+2 under competitive rules B.2 | Opponent receives 120 seconds; 60-second query is `NEITHER` |
| `ShortOfTimeRecording` | Standard chess, no increment, 240 seconds left | `must_record_moves`: `COMPUTED / FALSE_ONLY` |
| `DeviceWarning` | Electronic device evident; arbiter gave a warning | Loss and differing-penalty queries: `COMPUTED / TRUE_ONLY` |

All 18 original case/query expectations are retained and checked. The fixture export provides `caseNames`, `game`, `white`, `black`, `king`, `CaseName` and `getCaseInput(name)`. Each call returns an independent copy; an unknown name throws `RangeError`.

![Loss and the explicit inability-to-mate exception](npm/assets/loss-and-exception.svg)

## Facts and arbiter judgments

`getCaseInput` preserves the CLI's canonical assertions, constants, context and options. The loader supplies neither absent facts nor adjudications. The model's explicitly declared closures are part of its rules; they are not a general assumption that a missing fact is false.

For touch-move, use the two declared arguments — player and piece:

```js
import { open } from '@arxo/law';
import { loadModel } from '@arxo/canon-fide-chess/chess';
import { white, king, getCaseInput } from '@arxo/canon-fide-chess/examples/arbiter';

const model = await loadModel();
const chess = await open(model.spec, {
  offline: true, local: { packages: { [model.spec]: model.package } },
});
const answer = await chess.truth(
  'must_move_first_touched_piece', [white, king], getCaseInput('TouchIntentUnknown'),
);
const document = JSON.parse(new TextDecoder().decode(answer.document));
console.log(answer.evaluationStatus, answer.truthStatus); // REQUIRES_JUDGMENT, NEITHER
console.log(document.results[0].judgmentRequests);
```

A positive, explicitly `adjudicated` intentional-touch assertion establishes this model's obligation; that path is checked separately. The original missing-judgment fixture stays unchanged.

Missing empirical facts, negative facts and contradictory support retain `NEITHER`, `FALSE_ONLY` and `BOTH`. For the checked empirical conflict, SDK 0.4.3 returns `COMPUTED / BOTH`: the query was computed and both polarities are supported. Read both fields; do not collapse them to a Boolean. Exact Decimal inputs, such as recorded points, are strings (`'0.75'`).

<details>
<summary>Complete canonical input for SecondIllegal</summary>

```json
{
  "legalTime": "2023-06-01",
  "assertions": [
    {
      "contentHash": "sha256:696ba690ec316ad1654c94c94886b3d6e9764573460a0ed89f76280496c904fa",
      "evidence": [],
      "id": "urn:law:examples:chess:arbiter#player",
      "kind": "assertion",
      "literal": {
        "args": [
          {
            "id": "urn:example:chess:game",
            "kind": "entity_ref"
          },
          {
            "id": "urn:example:chess:white",
            "kind": "entity_ref"
          }
        ],
        "kind": "literal",
        "polarity": "positive",
        "predicate": "urn:fide:laws:clir:chess#player_of"
      },
      "origin": "case_input",
      "package": "urn:law:examples:chess:arbiter"
    },
    {
      "contentHash": "sha256:9f7706ed8482cd04f869afdd849b90eea3c2e42ca246bf932c8a20f77a1fcc15",
      "evidence": [],
      "id": "urn:law:examples:chess:arbiter#complete-mate-facts",
      "kind": "assertion",
      "literal": {
        "args": [
          {
            "id": "urn:example:chess:white",
            "kind": "entity_ref"
          }
        ],
        "kind": "literal",
        "polarity": "positive",
        "predicate": "urn:fide:laws:clir:chess#checked_player"
      },
      "origin": "case_input",
      "package": "urn:law:examples:chess:arbiter"
    },
    {
      "contentHash": "sha256:cd688c83624c70688f10ead443e5c46c32ad7d3310696caf6dad9b80be7c1cb0",
      "evidence": [],
      "id": "urn:law:examples:chess:arbiter#illegal-count",
      "kind": "assertion",
      "literal": {
        "args": [
          {
            "id": "urn:example:chess:white",
            "kind": "entity_ref"
          },
          {
            "kind": "value",
            "type": {
              "name": "urn:law:std#Integer"
            },
            "value": 2
          }
        ],
        "kind": "literal",
        "polarity": "positive",
        "predicate": "urn:fide:laws:clir:chess#completed_illegal_move_count"
      },
      "origin": "case_input",
      "package": "urn:law:examples:chess:arbiter"
    }
  ],
  "context": {
    "decisionTime": "2026-09-08T12:00:00Z",
    "knowledgeTime": "2026-09-08T12:00:00Z",
    "legalTime": "2023-06-01",
    "timezone": "UTC"
  },
  "options": {}
}
```

This input was captured by released CLI 0.2.3 from the retained `.lawcase`; the fixture generator does not reproduce chess semantics. [Fixture bytes](https://github.com/arxohq/arxo-fide-chess/blob/main/np