diff --git a/.specify/memory/constitution.md b/.specify/memory/constitution.md
index 88fc398..f116c77 100644
--- a/.specify/memory/constitution.md
+++ b/.specify/memory/constitution.md
@@ -1,6 +1,21 @@
 <!--
 Sync Impact Report
 ==================
+Version: 2.0.0 -> 2.0.1  (2026-10-14)
+
+Modified: Principle IV, wording -- records that the `extract-schema` operator
+          command connects without MCP_ALLOW_CYPHER, and why that is not an
+          instance with graph access.
+Added:    none
+Removed:  none
+
+Rationale: PATCH. No principle changed: the gate is about what an instance
+publishes, and the CLI publishes nothing. Written down because the principle
+says a new entrypoint belongs in the gate matrix, and this one deliberately
+sits outside it.
+
+Previous: 2.0.0 (2026-10-14), below.
+
 Version: 1.0.0 -> 2.0.0  (2026-10-14)
 
 Modified: Principle IV redefined -- "no Neo4j connection in any deployment"
@@ -93,6 +108,15 @@ was restored for internal use, on a different footing:
   and the registrars in every combination of the two variables and counts
   driver constructions. A new entrypoint belongs in that matrix.
 
+**Not an instance.** `reactome-mcp extract-schema` (`src/cli/extract-schema.ts`)
+opens the gate for its own process and nothing else: an operator runs it by
+hand against a database named on its command line, it writes that database's
+schema to a file, and it serves nothing -- it imports no server, tool, resource
+or transport, which the gate test asserts. It still connects through
+`getDriver()`, in READ sessions under the schema timeouts. A saved schema
+(`NEO4J_SCHEMA_FILE`) is read only behind the gate, and served only against
+the database whose fingerprint it carries.
+
 What would reverse this: graph access being needed on a public instance, or the
 gate failing open anywhere. Either means removing the capability again, not
 adding another check.
@@ -168,4 +192,4 @@ Amendments bump the version: MAJOR for a principle removed or redefined, MINOR
 for one added, PATCH for wording. Specs live in `specs/`; the ones that record
 why something is the way it is are as valuable as the ones that plan what is next.
 
-**Version**: 2.0.0 | **Ratified**: 2026-09-14 | **Last amended**: 2026-10-14
+**Version**: 2.0.1 | **Ratified**: 2026-09-14 | **Last amended**: 2026-10-14
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b90e28..b39228e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ All notable changes to this project are documented here. This project adheres to
 
   `NEO4J_DATABASE` now defaults to the server's default database, and `NEO4J_PASSWORD` to none (connect without credentials), rather than `graph.db` and `neo4j`.
 
+- **Save the graph schema, and serve it only against the database it came from.** `reactome-mcp extract-schema --uri … [--database] [--user] [--password-env VAR] [--out file]` runs the server's own extractor once and writes the schema JSON. It is an operator command, not an instance, so it does not need `MCP_ALLOW_CYPHER`; it reads in READ sessions under the same timeouts, refuses a password on the command line (it would show in `ps`) and takes it from the environment, and refuses to write a schema with unavailable sections. Every schema now carries `schemaFormat` (2) and a `source` fingerprint: Neo4j version and edition, the connected database's name, the Reactome release from `DBInfo` (absent where there is none), total node and relationship counts, digests of the label, relationship type and property key lists and of the indexes and constraints, and when it was taken. `NEO4J_SCHEMA_FILE` serves a saved schema instead of extracting at startup, but only after the live database gives the same fingerprint back (metadata and count-store queries, not the extraction) and the file agrees with its own fingerprint; anything else — another release or database, a changed count, a new label, type or property key, a changed index or constraint, another format, a missing, malformed or self-contradictory file — is warned about by name and the schema is extracted live. Changes that only touch property values or their types are not detected; the README says so. The CLI never echoes an argument value in a usage error, and refuses to write a schema whose body disagrees with its fingerprint (the database changed during the run). With graph access off the file is never read. The schema digest names the Reactome release. The README covers pointing an internal instance at your own database, and producing `reactome-<release>-schema.json` in the release pipeline.
+
 - **`MCP_TOOL_GROUPS` — choose which tools an instance publishes.** All 59 register by default, so a local stdio user is unaffected; a hosted instance names the groups it means to serve (`search`, `pathway`, `entity`, `analysis`, `export`, `interactors`, `gsa`, `utilities`).
 
   It is a **registration** switch, not a documentation one. An omitted group's tools are not registered, do not appear in `tools/list`, are not mentioned in the instructions the server sends on connection, and neither are its **resources** — omitting `analysis` withholds `reactome://analysis/{token}` as well, since a capability moved to a URI is not a capability withheld. A tool described nowhere but still answering is the divergence that let this server advertise Cypher tools it had not registered.
@@ -36,6 +38,7 @@ All notable changes to this project are documented here. This project adheres to
 - **`reactome_query` returned pretty-printed JSON**, which cost ~23% more tokens for whitespace no model needs. Objects too large to return whole are now described — field names, shapes and sizes, with a pointer to the `attribute` argument — instead of being truncated into invalid JSON. Metabolism goes from 43,457 characters of severed object to 1,327 characters of usable map.
 - **`events_hierarchy` failed every call that did not name a species.** Its default was `"Homo sapiens"`, which that endpoint answers with HTTP 500; `"9606"` returns 200.
 - A failed Neo4j driver close rejected with nobody listening — `process.once` was handed an `async` function.
+- Every Neo4j driver build added its own `SIGINT`/`SIGTERM`/`beforeExit` listeners and nothing removed them, so a process that closed and reconnected accumulated them past Node's leak warning. They are added once per process.
 - `fetchWithRetry` rethrew `lastError`, typed `unknown`, so a non-`Error` rejection reached callers as something they could not read `.message` off.
 
 ### Added
diff --git a/README.md b/README.md
index 4eb9b2f..0da3ab5 100644
--- a/README.md
+++ b/README.md
@@ -113,6 +113,7 @@ Optional:
 | `NEO4J_PASSWORD` | _(unset)_ | unset connects without credentials, for a database with authentication disabled |
 | `NEO4J_DATABASE` | _(server default)_ | Neo4j Community serves a single database, so this is rarely needed |
 | `CYPHER_QUERY_TIMEOUT_MS` | `30000` | server-side transaction timeout for `reactome_cypher_*` queries |
+| `NEO4J_SCHEMA_FILE` | _(unset)_ | a schema saved by [`extract-schema`](#saving-the-schema-extract-schema), served instead of extracting one when it matches the database; ignored entirely while graph access is off |
 
 **Read-only safeguards.** Every query runs in a READ-mode session, so the
 database refuses `CREATE`, `MERGE`, `DELETE`, `SET` and `REMOVE`. Before a
@@ -158,6 +159,116 @@ is read once in the background at startup and cached; on the full graph that
 can take a while, and a section the database cannot provide is reported as
 unavailable rather than shown empty.
 
+### Saving the schema: `extract-schema`
+
+Reading the schema of the full Reactome graph takes about a minute. To skip
+that at startup, save it once and point the server at the file:
+
+```bash
+NEO4J_PASSWORD=… node dist/index.js extract-schema \
+  --uri bolt://127.0.0.1:7687 --out reactome-schema.json
+# installed from npm: npx reactome-mcp extract-schema …
+
+NEO4J_URI=bolt://127.0.0.1:7687 MCP_ALLOW_CYPHER=1 \
+  NEO4J_SCHEMA_FILE=reactome-schema.json node dist/index.js
+```
+
+| Option | |
+|---|---|
+| `--uri <uri>` | the database (required) |
+| `--database <name>` | default `NEO4J_DATABASE`, else the server's default database |
+| `--user <name>` | default `NEO4J_USER`, else `neo4j` |
+| `--password-env <VAR>` | read the password from `VAR` instead of `NEO4J_PASSWORD` |
+| `--out <file>` | write here; without it the JSON goes to stdout |
+
+There is no `--password`, and passing one is refused: a command line is visible
+to every user of the machine in `ps`. The password comes from the environment.
+
+`extract-schema` runs the server's own extractor, read-only and under the same
+timeouts, so the file has exactly the structure of the `reactome://graph/schema`
+resource. It does not need `MCP_ALLOW_CYPHER` — it is a command an operator runs
+by hand, not a server, and it publishes nothing. It refuses to write a schema
+with sections it could not read, since a saved schema would keep that gap for as
+long as it is used, or one whose body disagrees with its own fingerprint, which
+means the database was written to during the run. Usage errors name the flag at
+most and never echo a value.
+
+**The file is only served against the database it came from.** Every schema
+carries a `schemaFormat` number (currently `2`) and a `source` fingerprint:
+
+- Neo4j version and edition, and the name of the database actually connected to
+- the Reactome release from the graph's `DBInfo` node (absent on a graph without one)
+- total node and relationship counts
+- digests of the label, relationship type and property key lists, and of the
+  indexes (name, labels, properties, state) and constraints
+- when it was taken (recorded, not compared)
+
+On its first schema request the server reads the same fingerprint from the live
+database — metadata procedures and count-store lookups, nothing that scans the
+nodes or their properties, rather than the full extraction — and serves the
+file only if every field agrees, the format is one it reads, and the file agrees
+with its own fingerprint. When it does, it logs `graph schema served from file`
+with the file, release and database. Otherwise it logs a warning naming the
+difference and extracts the schema live, as if no file were set. With graph
+access off, `NEO4J_SCHEMA_FILE` is not read at all.
+
+| Detected (the file is not used) | Not detected (the file is still used) |
+|---|---|
+| another release, database or Neo4j version | a property's value changing |
+| a node or relationship added or removed | a property's value type changing (say, a string becoming a list) |
+| a new label, relationship type or property key (`SET n.newProp`) | an existing property key set on nodes that lacked it |
+| an index or constraint created, dropped or no longer online | one node deleted and another added with the same labels, keys and totals |
+| an older format, or a missing, malformed or self-contradictory file | a property key no longer used anywhere — Neo4j keeps key tokens once created |
+
+So a snapshot is safe against a different database and against most structural
+edits, but it is a fingerprint, not a proof: after edits that only change
+values, re-run `extract-schema` or unset `NEO4J_SCHEMA_FILE`.
+
+**From the release pipeline.** Once a release's graph database image is built,
+the same command against a container started from it produces a schema that can
+be published beside the image as an optional artifact:
+
+```bash
+docker run -d --name graphdb-schema -p 127.0.0.1:7687:7687 <the new graph database image>
+node dist/index.js extract-schema --uri bolt://127.0.0.1:7687 \
+  --out reactome-<release>-schema.json
+docker rm -f graphdb-schema
+```
+
+An instance run against that image can then set `NEO4J_SCHEMA_FILE` to the
+published file; one run against anything else will fall back to live extraction
+on its own.
+
+### Pointing at your own database
+
+A curator, or anyone with a Reactome-shaped graph of their own, can run an
+internal instance against it. The same rule applies as everywhere else here:
+**only on an instance that is not publicly reachable** — on your own machine
+over stdio, or bound to loopback.
+
+```bash
+NEO4J_URI=bolt://127.0.0.1:7687 \
+NEO4J_USER=neo4j NEO4J_PASSWORD=… \
+NEO4J_DATABASE=<your database, if not the default> \
+MCP_ALLOW_CYPHER=1 \
+node dist/index.js
+```
+
+Nothing else is needed: the schema the Cypher tools describe is read from your
+database at startup, not shipped with the server, so it reflects your labels,
+properties and counts. A database without a `DBInfo` node is fine; the schema
+simply names no release.
+
+To skip the extraction on later starts, save your database's schema with
+`extract-schema` and set `NEO4J_SCHEMA_FILE` to it. The fingerprint check is
+what makes this safe to get wrong: a schema saved from the release graph will
+not match your database, so it is not used against it, and nor is your own
+snapshot once your database has changed in a way the fingerprint sees — a node
+or relationship added or removed, a new label, relationship type or property
+key, an index or constraint changed. In those cases the server warns and reads
+the schema live. Edits that only change property values or their types are
+**not** seen (see the table above); after those, re-run `extract-schema`.
+
 ## Usage
 
 ### With Claude Desktop
diff --git a/src/cli/extract-schema.ts b/src/cli/extract-schema.ts
new file mode 100644
index 0000000..30412aa
--- /dev/null
+++ b/src/cli/extract-schema.ts
@@ -0,0 +1,199 @@
+import { rename, rm, writeFile } from "node:fs/promises";
+import { closeDriver } from "../clients/neo4j.js";
+import { fetchGraphSchema } from "../graph/schema.js";
+import { schemaInconsistencies } from "../graph/schema-source.js";
+
+/**
+ * `reactome-mcp extract-schema` -- write a database's graph schema to JSON.
+ *
+ *     reactome-mcp extract-schema --uri bolt://127.0.0.1:7687 [--database NAME]
+ *       [--user USER] [--password-env VAR] [--out FILE]
+ *
+ * It runs the server's own extractor, `fetchGraphSchema()`, so a saved schema
+ * has exactly the structure the server builds live, `source` fingerprint
+ * included; there is no second implementation to drift from the first. The
+ * output is what `NEO4J_SCHEMA_FILE` reads.
+ *
+ * **Not an instance, so not behind MCP_ALLOW_CYPHER.** That switch is consent
+ * to *publish* query access. This runs once, by hand, against a database the
+ * operator names on the command line, and serves nothing -- it imports no
+ * server, tool, resource or transport, which `tests/graph-access-gate.test.ts`
+ * checks. It opens the gate for its own process only, after its arguments are
+ * read, and connects through the same gated driver, so it runs the same READ
+ * sessions under the same timeouts as the server.
+ *
+ * **No password argument.** A command line is visible to every user of the
+ * machine (`ps`), so the password comes from NEO4J_PASSWORD, or from the
+ * variable `--password-env` names, and `--password` is refused.
+ *
+ * A schema with unavailable sections is not written: a saved schema is served
+ * for as long as its database matches, so a gap in it would never be filled.
+ * Nor is one whose body disagrees with its own fingerprint -- the database
+ * was written to while it was read -- since the server would refuse it.
+ *
+ * **No value is ever echoed.** A usage error names the flag at most: a
+ * mistyped `--password` is the likeliest mistake, and its value the
+ * password.
+ *
+ * Returns the exit code: 0 written, 1 extraction or write failed, 2 usage.
+ */
+
+const USAGE = `Usage: reactome-mcp extract-schema --uri <bolt-uri> [options]
+
+Write the graph schema of a Neo4j database as JSON, in the form the server's
+NEO4J_SCHEMA_FILE reads. Read-only. Does not need MCP_ALLOW_CYPHER.
+
+  --uri <uri>           the database, e.g. bolt://127.0.0.1:7687 (required)
+  --database <name>     database name (default: NEO4J_DATABASE, else the server default)
+  --user <name>         user (default: NEO4J_USER, else neo4j)
+  --password-env <VAR>  read the password from environment variable VAR
+                        (default: NEO4J_PASSWORD; unset connects without credentials)
+  --out <file>          write here instead of stdout
+  --help                show this
+
+There is no --password: a password on the command line is visible in \`ps\`.
+`;
+
+export interface CliIo {
+  stdout: (text: string) => void;
+  stderr: (text: string) => void;
+}
+
+const processIo: CliIo = {
+  stdout: text => void process.stdout.write(text),
+  stderr: text => void process.stderr.write(text),
+};
+
+const VALUE_FLAGS = ["--uri", "--database", "--user", "--password-env", "--out"] as const;
+type ValueFlag = (typeof VALUE_FLAGS)[number];
+
+class UsageError extends Error {}
+
+/** A name an environment variable can have; anything else is not echoed. */
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function parse(args: string[]): { help: boolean; values: Partial<Record<ValueFlag, string>> } {
+  const values: Partial<Record<ValueFlag, string>> = {};
+  let help = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+      continue;
+    }
+    // Refused by name and never echoed: the value is the secret.
+    if (arg === "-p" || arg === "--password" || arg.startsWith("--password=")) {
+      throw new UsageError(
+        "a password is not accepted on the command line, where `ps` shows it to every " +
+          "user of the machine. Put it in the environment: NEO4J_PASSWORD, or the " +
+          "variable named by --password-env."
+      );
+    }
+    if (!arg.startsWith("-")) {
+      throw new UsageError(
+        "unexpected value on the command line (not shown); every value follows its flag"
+      );
+    }
+    const eq = arg.indexOf("=");
+    const flag = (eq > 0 ? arg.slice(0, eq) : arg) as ValueFlag;
+    // The flag only: what follows `=` may be a secret.
+    if (!VALUE_FLAGS.includes(flag)) throw new UsageError(`unknown option: ${flag}`);
+    const value = eq > 0 ? arg.slice(eq + 1) : args[++i];
+    if (value === undefined || value === "" || (eq < 0 && value.startsWith("--"))) {
+      throw new UsageError(`${flag} needs a value`);
+    }
+    if (flag === "--password-env" && !ENV_NAME.test(value)) {
+      // Most likely the password itself, given where a variable name goes.
+      throw new UsageError(
+        "--password-env takes the name of an environment variable, and what was given " +
+          "(not shown) is not a valid environment variable name"
+      );
+    }
+    values[flag] = value;
+  }
+  return { help, values };
+}
+
+export async function runExtractSchema(args: string[], io: CliIo = processIo): Promise<number> {
+  let values: Partial<Record<ValueFlag, string>>;
+  try {
+    const parsed = parse(args);
+    if (parsed.help) {
+      io.stdout(USAGE);
+      return 0;
+    }
+    values = parsed.values;
+    if (!values["--uri"]) throw new UsageError("--uri is required");
+  } catch (error) {
+    if (!(error instanceof UsageError)) throw error;
+    io.stderr(`extract-schema: ${error.message}\n\n${USAGE}`);
+    return 2;
+  }
+
+  const passwordVar = values["--password-env"];
+  let password = process.env.NEO4J_PASSWORD;
+  if (passwordVar) {
+    password = process.env[passwordVar];
+    if (!password) {
+      // Connecting without credentials instead would hide the typo.
+      io.stderr(`extract-schema: --password-env names ${passwordVar}, which is not set\n`);
+      return 2;
+    }
+  }
+
+  // This process only, and only now that the arguments are known good.
+  process.env.NEO4J_URI = values["--uri"];
+  process.env.MCP_ALLOW_CYPHER = "1";
+  // Always extract: an inherited snapshot would be copied, not regenerated.
+  delete process.env.NEO4J_SCHEMA_FILE;
+  if (values["--database"]) process.env.NEO4J_DATABASE = values["--database"];
+  if (values["--user"]) process.env.NEO4J_USER = values["--user"];
+  if (password === undefined) delete process.env.NEO4J_PASSWORD;
+  else process.env.NEO4J_PASSWORD = password;
+
+  const out = values["--out"];
+  const partial = out ? `${out}.${process.pid}.partial` : undefined;
+  try {
+    const schema = await fetchGraphSchema();
+    if (schema.unavailable.length > 0) {
+      io.stderr(
+        "extract-schema: not written; these sections could not be read:\n" +
+          schema.unavailable.map(u => `  ${u.section}: ${u.reason}\n`).join("")
+      );
+      return 1;
+    }
+    const inconsistent = schema.source
+      ? schemaInconsistencies({ ...schema, source: schema.source })
+      : [];
+    if (inconsistent.length > 0) {
+      io.stderr(
+        "extract-schema: not written; the database changed while it was read, so the schema " +
+          "disagrees with its own fingerprint. Run it again when the database is quiet:\n" +
+          inconsistent.map(d => `  ${d}\n`).join("")
+      );
+      return 1;
+    }
+
+    const json = JSON.stringify(schema, null, 2) + "\n";
+    if (out && partial) {
+      // Written aside and renamed, so a failed run never leaves a truncated
+      // file where a good one is expected.
+      await writeFile(partial, json);
+      await rename(partial, out);
+      const s = schema.source;
+      io.stderr(
+        `extract-schema: wrote ${out} (release ${s?.releaseNumber ?? "none"}, ` +
+          `${s?.nodeCount ?? "?"} nodes, ${s?.relCount ?? "?"} relationships)\n`
+      );
+    } else {
+      io.stdout(json);
+    }
+    return 0;
+  } catch (error) {
+    if (partial) await rm(partial, { force: true });
+    io.stderr(`extract-schema: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  } finally {
+    await closeDriver();
+  }
+}
diff --git a/src/clients/neo4j.ts b/src/clients/neo4j.ts
index e272264..36b08df 100644
--- a/src/clients/neo4j.ts
+++ b/src/clients/neo4j.ts
@@ -19,6 +19,7 @@ import { logger } from "../logger.js";
 type Neo4jModule = Pick<typeof import("neo4j-driver"), "driver" | "auth" | "session" | "int">;
 
 let driverPromise: Promise<{ neo4j: Neo4jModule; driver: Driver }> | null = null;
+let shutdownHooked = false;
 
 function isLoopback(uri: string): boolean {
   try {
@@ -45,19 +46,25 @@ async function build(): Promise<{ neo4j: Neo4jModule; driver: Driver }> {
   const driver = neo4j.driver(uri, auth, { disableLosslessIntegers: true });
   logger.info("neo4j driver initialized", { database: database ?? "(server default)" });
 
-  // process.once expects a void-returning listener. Handing it an async
-  // function meant a failed close rejected with nobody listening, which Node
-  // turns into a hard exit on unhandled rejection.
-  const onShutdown = () => {
-    void closeDriver().catch((error: unknown) => {
-      logger.warn("neo4j driver close failed during shutdown", {
-        error: error instanceof Error ? error.message : String(error),
+  // Hooked once per process, not once per driver: closeDriver() closes
+  // whichever driver is current, and hooking every build piled listeners up
+  // in a process that closes and reconnects.
+  if (!shutdownHooked) {
+    shutdownHooked = true;
+    // process.once expects a void-returning listener. Handing it an async
+    // function meant a failed close rejected with nobody listening, which Node
+    // turns into a hard exit on unhandled rejection.
+    const onShutdown = () => {
+      void closeDriver().catch((error: unknown) => {
+        logger.warn("neo4j driver close failed during shutdown", {
+          error: error instanceof Error ? error.message : String(error),
+        });
       });
-    });
-  };
-  process.once("SIGINT", onShutdown);
-  process.once("SIGTERM", onShutdown);
-  process.once("beforeExit", onShutdown);
+    };
+    process.once("SIGINT", onShutdown);
+    process.once("SIGTERM", onShutdown);
+    process.once("beforeExit", onShutdown);
+  }
 
   return { neo4j, driver };
 }
diff --git a/src/config.ts b/src/config.ts
index 31d2a4e..93b5e65 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -89,6 +89,15 @@ export function neo4jConnection(env: NodeJS.ProcessEnv = process.env) {
   };
 }
 
+/**
+ * A graph schema saved by `reactome-mcp extract-schema`, served instead of
+ * extracting one when it describes the database at NEO4J_URI. Read only when
+ * graph access is on; see `src/graph/schema.ts`.
+ */
+export function neo4jSchemaFile(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  return env.NEO4J_SCHEMA_FILE?.trim() || undefined;
+}
+
 /**
  * Server-side timeout on every Cypher query, in milliseconds. The database
  * terminates a transaction that runs longer.
diff --git a/src/graph/format-schema.ts b/src/graph/format-schema.ts
index 91948b1..662b8ee 100644
--- a/src/graph/format-schema.ts
+++ b/src/graph/format-schema.ts
@@ -54,8 +54,11 @@ export function formatGraphSchemaMarkdown(schema: GraphSchema): string {
   const lines: string[] = [];
   lines.push(`## Reactome Graph Schema`);
   const dbComp = schema.dbComponents[0];
+  const release = schema.source?.releaseNumber;
   lines.push(
-    `**Neo4j:** ${dbComp?.versions?.[0] ?? "?"} ${dbComp?.edition ?? ""} · **Fetched:** ${schema.fetchedAt}`
+    `**Neo4j:** ${dbComp?.versions?.[0] ?? "?"} ${dbComp?.edition ?? ""} · ` +
+      (release === undefined ? "" : `**Reactome release:** ${release} · `) +
+      `**Fetched:** ${schema.fetchedAt}`
   );
   lines.push(
     `**Totals:** ${stats.nodeCount.toLocaleString()} nodes · ${stats.relCount.toLocaleString()} relationships · ${labelEntries.length} labels · ${relEntries.length} relationship types`
diff --git a/src/graph/gate.ts b/src/graph/gate.ts
index 06d4bb6..7610b68 100644
--- a/src/graph/gate.ts
+++ b/src/graph/gate.ts
@@ -22,6 +22,15 @@
  *
  * Read from the environment on every call rather than captured at import, so
  * there is one copy of the answer and it cannot go stale.
+ *
+ * One process sets both for itself: `reactome-mcp extract-schema`
+ * (`src/cli/extract-schema.ts`), an operator command that saves a database's
+ * schema to a file. It is not an instance -- it runs once, by hand, against a
+ * database named on its command line, and imports no server, tool, resource
+ * or transport (asserted in the gate test) -- so the switch that means
+ * "publish query access" does not apply to it. It still connects through the
+ * gated driver, so it reads in the same READ sessions under the same
+ * timeouts.
  */
 export function isGraphAccessEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
   return Boolean(env.NEO4J_URI?.trim()) && env.MCP_ALLOW_CYPHER === "1";
diff --git a/src/graph/schema-source.ts b/src/graph/schema-source.ts
new file mode 100644
index 0000000..4016dce
--- /dev/null
+++ b/src/graph/schema-source.ts
@@ -0,0 +1,293 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import type { GraphSchema } from "./schema.js";
+
+/**
+ * Which database a schema describes, and how to tell whether a schema saved
+ * to a file still describes the database the server is pointed at.
+ *
+ * A saved schema (`reactome-mcp extract-schema`, served through
+ * `NEO4J_SCHEMA_FILE`) is a description of one database. Served against
+ * another, it would be read as a description of that one -- labels that are
+ * not there, counts that are wrong -- which is a confident wrong answer, the
+ * failure this server is built to avoid. So every schema carries a
+ * fingerprint, and a saved one is served only when the live database gives
+ * the same fingerprint back.
+ *
+ * The fingerprint is the cheap part of the schema -- metadata reads and
+ * count-store lookups, nothing that scans nodes or their properties:
+ *
+ *   the Neo4j version and edition, and the name of the database connected to
+ *   the release in the DBInfo node, where there is one
+ *   total node and relationship counts
+ *   digests of the label, relationship type and property key lists, and of
+ *   the indexes (name, labels, properties, state) and constraints
+ *
+ * So a different release or database, a node or relationship added or
+ * removed, a new label, type or property key (`SET n.newProp`), and an index
+ * or constraint created, dropped or no longer online all fail to match.
+ *
+ * What it does **not** see, because seeing it would mean reading the data:
+ * a change that keeps every total and every list as it was -- a property's
+ * value changing, or its type (a string becoming a list), or an existing key
+ * being set on nodes that lacked it, or one node deleted and another added
+ * with the same labels. Property keys are tokens that Neo4j keeps once
+ * created, so a key no longer used anywhere still counts as present. It is a
+ * fingerprint, not proof of identity.
+ */
+
+/**
+ * The layout of the schema JSON. Bump it whenever a field is added, removed or
+ * changes meaning, so a server never reads a file written for another layout
+ * as if it were its own.
+ */
+export const SCHEMA_FORMAT = 2;
+
+export interface SchemaSource {
+  /** First component reported by `dbms.components()`. */
+  neo4jVersion: string | null;
+  neo4jEdition: string | null;
+  /** The database actually connected to (`db.info()`), not the one asked for. */
+  database: string | null;
+  /**
+   * `releaseNumber` of the graph's DBInfo node. Absent, not null, on a
+   * database without one -- a curator database, or not Reactome's.
+   */
+  releaseNumber?: number | string;
+  nodeCount: number;
+  relCount: number;
+  /** sha256 of each list in canonical order; see `digestNames` and friends. */
+  labelsDigest: string;
+  relationshipTypesDigest: string;
+  propertyKeysDigest: string;
+  indexesDigest: string;
+  constraintsDigest: string;
+  /** When this fingerprint was read. Not compared. */
+  generatedAt: string;
+}
+
+/** The fields compared, in the order a mismatch is reported. */
+const COMPARED = [
+  "neo4jVersion",
+  "neo4jEdition",
+  "database",
+  "releaseNumber",
+  "nodeCount",
+  "relCount",
+  "labelsDigest",
+  "relationshipTypesDigest",
+  "propertyKeysDigest",
+  "indexesDigest",
+  "constraintsDigest",
+] as const;
+
+const show = (value: unknown) => (value === undefined ? "(none)" : JSON.stringify(value));
+
+const sha256 = (keys: string[]) =>
+  createHash("sha256")
+    .update(JSON.stringify([...new Set(keys)].sort()))
+    .digest("hex");
+
+/** A list of names, whatever order the database gives them in. */
+export const digestNames = (names: string[]) => sha256(names);
+
+/** Indexes by what a query planner cares about: name, target, and whether it is usable. */
+export const digestIndexes = (indexes: GraphSchema["indexes"]) =>
+  sha256(
+    indexes.map(i =>
+      JSON.stringify([
+        i.name ?? null,
+        i.labelsOrTypes ?? null,
+        i.properties ?? null,
+        i.state ?? null,
+      ])
+    )
+  );
+
+/** Constraints by name and target, or by description where only db.constraints() answered. */
+export const digestConstraints = (constraints: GraphSchema["constraints"]) =>
+  sha256(
+    constraints.map(c =>
+      JSON.stringify([
+        c.name ?? null,
+        c.labelsOrTypes ?? null,
+        c.properties ?? null,
+        c.description ?? null,
+      ])
+    )
+  );
+
+/** Digests read as their first twelve characters; the rest says nothing more to a reader. */
+const showField = (_field: string, value: unknown) =>
+  typeof value === "string" && /^[0-9a-f]{64}$/.test(value) ? value.slice(0, 12) : show(value);
+
+/**
+ * What differs between the fingerprint a file was saved with and the live
+ * database's, as `field: file X, database Y`. Empty means they match.
+ */
+export function sourceMismatches(file: SchemaSource, live: SchemaSource): string[] {
+  const out: string[] = [];
+  for (const field of COMPARED) {
+    const a = file[field];
+    const b = live[field];
+    // A release stored as 97 and read back as "97" is the same release.
+    const same = a === undefined || b === undefined ? a === b : String(a) === String(b);
+    if (!same) {
+      const name = field.replace(/Digest$/, "");
+      out.push(`${name}: file ${showField(field, a)}, database ${showField(field, b)}`);
+    }
+  }
+  return out;
+}
+
+const names = z.array(z.string()).nullable().optional();
+
+const digest = z.string().regex(/^[0-9a-f]{64}$/);
+
+const sourceSchema = z.object({
+  database: z.string().nullable(),
+  labelsDigest: digest,
+  relationshipTypesDigest: digest,
+  propertyKeysDigest: digest,
+  indexesDigest: digest,
+  constraintsDigest: digest,
+  neo4jVersion: z.string().nullable(),
+  neo4jEdition: z.string().nullable(),
+  releaseNumber: z.union([z.number(), z.string()]).optional(),
+  nodeCount: z.number(),
+  relCount: z.number(),
+  generatedAt: z.string(),
+});
+
+const graphSchemaSchema = z.object({
+  schemaFormat: z.number(),
+  fetchedAt: z.string(),
+  source: sourceSchema,
+  dbComponents: z.array(
+    z.object({ name: z.string(), versions: z.array(z.string()), edition: z.string() })
+  ),
+  stats: z.object({
+    nodeCount: z.number(),
+    relCount: z.number(),
+    labels: z.record(z.string(), z.number()),
+    relTypesCount: z.record(z.string(), z.number()),
+  }),
+  patterns: z.array(z.object({ start: z.string(), type: z.string(), end: z.string() })),
+  nodeTypeProperties: z.array(
+    z.object({
+      nodeType: z.string(),
+      nodeLabels: z.array(z.string()),
+      propertyName: z.string(),
+      propertyTypes: z.array(z.string()),
+      mandatory: z.boolean(),
+    })
+  ),
+  relTypeProperties: z.array(
+    z.object({
+      relType: z.string(),
+      propertyName: z.string(),
+      propertyTypes: z.array(z.string()),
+      mandatory: z.boolean(),
+    })
+  ),
+  indexes: z.array(
+    z.object({
+      name: z.string().optional(),
+      type: z.string().optional(),
+      entityType: z.string().optional(),
+      labelsOrTypes: names,
+      properties: names,
+      state: z.string().optional(),
+    })
+  ),
+  constraints: z.array(
+    z.object({
+      name: z.string().optional(),
+      type: z.string().optional(),
+      entityType: z.string().optional(),
+      labelsOrTypes: names,
+      properties: names,
+      description: z.string().optional(),
+    })
+  ),
+  unavailable: z.array(z.object({ section: z.string(), reason: z.string() })),
+});
+
+/**
+ * Read a saved schema, or throw saying why it cannot be used: not JSON,
+ * another format, no fingerprint, a missing or mistyped section, or sections
+ * that were unavailable when it was saved (a saved schema is served for as
+ * long as the database matches, so a gap in it would never be filled).
+ *
+ * Checked field by field rather than cast, because a cast would let a
+ * truncated or hand-edited file through as a schema.
+ */
+export function parseSchemaSnapshot(text: string): GraphSchema & { source: SchemaSource } {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`not valid JSON (${error instanceof Error ? error.message : String(error)})`, {
+      cause: error,
+    });
+  }
+
+  const format = (raw as { schemaFormat?: unknown } | null)?.schemaFormat;
+  if (format !== SCHEMA_FORMAT) {
+    throw new Error(`schemaFormat is ${show(format)}; this server reads ${SCHEMA_FORMAT}`);
+  }
+
+  const parsed = graphSchemaSchema.safeParse(raw);
+  if (!parsed.success) {
+    const where = parsed.error.issues
+      .slice(0, 3)
+      .map(i => `${i.path.join(".") || "(root)"}: ${i.message}`)
+      .join("; ");
+    throw new Error(`not a schema this server can read (${where})`);
+  }
+
+  const schema = parsed.data;
+  if (schema.unavailable.length > 0) {
+    throw new Error(
+      `saved with unavailable sections (${schema.unavailable.map(u => u.section).join(", ")})`
+    );
+  }
+  const inconsistent = schemaInconsistencies(schema);
+  if (inconsistent.length > 0) {
+    throw new Error(`its body disagrees with its own fingerprint (${inconsistent.join("; ")})`);
+  }
+  return schema;
+}
+
+/**
+ * Where a schema's body disagrees with its own `source` fingerprint, as
+ * `field: body X, source Y`. Empty when consistent.
+ *
+ * The two are read by separate queries, so a database written to during an
+ * extraction gives a schema that matches neither the before nor the after;
+ * and a hand-edited file can change one without the other. Either way the
+ * fingerprint would vouch for a body it does not describe. Property keys and
+ * the database name have nothing in the body to check against.
+ */
+export function schemaInconsistencies(schema: GraphSchema & { source: SchemaSource }): string[] {
+  const { source, stats } = schema;
+  const out: string[] = [];
+  const check = (field: string, body: unknown, fingerprint: unknown) => {
+    if (body !== fingerprint) {
+      out.push(`${field}: body ${showField(field, body)}, source ${showField(field, fingerprint)}`);
+    }
+  };
+  check("nodeCount", stats.nodeCount, source.nodeCount);
+  check("relCount", stats.relCount, source.relCount);
+  check("labels", digestNames(Object.keys(stats.labels)), source.labelsDigest);
+  check(
+    "relationshipTypes",
+    digestNames(Object.keys(stats.relTypesCount)),
+    source.relationshipTypesDigest
+  );
+  check("indexes", digestIndexes(schema.indexes), source.indexesDigest);
+  check("constraints", digestConstraints(schema.constraints), source.constraintsDigest);
+  check("neo4jVersion", schema.dbComponents[0]?.versions[0] ?? null, source.neo4jVersion);
+  check("neo4jEdition", schema.dbComponents[0]?.edition ?? null, source.neo4jEdition);
+  return out;
+}
diff --git a/src/graph/schema.ts b/src/graph/schema.ts
index 41fce0a..2ac1a5d 100644
--- a/src/graph/schema.ts
+++ b/src/graph/schema.ts
@@ -1,5 +1,17 @@
+import { readFile } from "node:fs/promises";
 import { runRead } from "../clients/neo4j.js";
+import { neo4jSchemaFile } from "../config.js";
 import { logger } from "../logger.js";
+import { GRAPH_ACCESS_OFF, isGraphAccessEnabled } from "./gate.js";
+import {
+  digestConstraints,
+  digestIndexes,
+  digestNames,
+  parseSchemaSnapshot,
+  SCHEMA_FORMAT,
+  sourceMismatches,
+  type SchemaSource,
+} from "./schema-source.js";
 
 /**
  * The live graph schema, built from Neo4j's **built-in** procedures only.
@@ -44,11 +56,21 @@ import { logger } from "../logger.js";
  *
  * On that graph the whole fetch took about 65 s (2.96M nodes, 11.5M
  * relationships, 108 labels, 88 types, 5,669 label-level patterns), almost
- * all of it `db.schema.nodeTypeProperties()`. Hence the warm-up, and the
- * timeout below.
+ * all of it `db.schema.nodeTypeProperties()`. Hence the warm-up, the timeout
+ * below, and `NEO4J_SCHEMA_FILE` -- a schema saved earlier by
+ * `reactome-mcp extract-schema`, served instead when the database it was
+ * saved from is the one the server is pointed at (see `schema-source.ts`).
  */
 export interface GraphSchema {
+  /** The layout of this structure; see `SCHEMA_FORMAT`. */
+  schemaFormat: number;
+  /** When the schema was read -- or last re-read, for a retried section. */
   fetchedAt: string;
+  /**
+   * Which database this describes. Null only when the fingerprint itself
+   * could not be read, in which case `unavailable` names `source`.
+   */
+  source: SchemaSource | null;
   dbComponents: Array<{ name: string; versions: string[]; edition: string }>;
   stats: {
     nodeCount: number;
@@ -109,7 +131,7 @@ export const SCHEMA_RETRY_AFTER_MS = 5 * 60_000;
 let schemaCache: { schema: GraphSchema; at: number } | null = null;
 let schemaPending: Promise<GraphSchema> | null = null;
 
-type Section = keyof Omit<GraphSchema, "fetchedAt" | "unavailable">;
+type Section = keyof Omit<GraphSchema, "schemaFormat" | "fetchedAt" | "unavailable">;
 
 class SectionUnavailable extends Error {}
 
@@ -159,14 +181,88 @@ async function countEach(tokens: string[], pattern: (quoted: string) => string)
   return Object.fromEntries(rows.map(r => [r.key, Number(r.count)]));
 }
 
+const COMPONENTS =
+  "CALL dbms.components() YIELD name, versions, edition RETURN name, versions, edition";
+// Both totals are answered from the count store, not by scanning.
+const NODE_TOTAL = "MATCH (n) RETURN count(n) AS count";
+const REL_TOTAL = "MATCH ()-[r]->() RETURN count(r) AS count";
+// Reactome's graph has one DBInfo node; a curator or non-Reactome graph has
+// none, and this returns no row. Ordered so that a graph with several gives
+// the same answer every time.
+const RELEASE =
+  "MATCH (d:DBInfo) RETURN d.releaseNumber AS releaseNumber ORDER BY releaseNumber DESC LIMIT 1";
+const DATABASE = "CALL db.info() YIELD name RETURN name";
+const LABELS = "CALL db.labels() YIELD label RETURN label";
+const REL_TYPES = "CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType";
+const PROPERTY_KEYS = "CALL db.propertyKeys() YIELD propertyKey RETURN propertyKey";
+
+const fetchIndexes = () =>
+  firstThatWorks<GraphSchema["indexes"][number]>([
+    "SHOW INDEXES YIELD name, type, entityType, labelsOrTypes, properties, state RETURN name, type, entityType, labelsOrTypes, properties, state",
+    "CALL db.indexes() YIELD name, type, entityType, labelsOrTypes, properties, state RETURN name, type, entityType, labelsOrTypes, properties, state",
+  ]);
+
+const fetchConstraints = () =>
+  firstThatWorks<GraphSchema["constraints"][number]>([
+    "SHOW CONSTRAINTS YIELD name, type, entityType, labelsOrTypes, properties RETURN name, type, entityType, labelsOrTypes, properties",
+    "CALL db.constraints() YIELD name, description RETURN name, description",
+  ]);
+
+/**
+ * The cheap part of the schema that identifies the database: metadata reads
+ * and count-store lookups, none of which scans nodes or their properties.
+ * This is what a saved schema is checked against before it is served; what
+ * it catches and what it cannot is set out in `schema-source.ts`.
+ */
+export async function fetchSourceFingerprint(): Promise<SchemaSource> {
+  const [
+    components,
+    database,
+    release,
+    nodeTotal,
+    relTotal,
+    labels,
+    relTypes,
+    propertyKeys,
+    indexes,
+    constraints,
+  ] = await Promise.all([
+    firstThatWorks<{ versions?: string[]; edition?: string }>([COMPONENTS]),
+    firstThatWorks<{ name: string }>([DATABASE]),
+    firstThatWorks<{ releaseNumber: unknown }>([RELEASE]),
+    firstThatWorks<{ count: number }>([NODE_TOTAL]),
+    firstThatWorks<{ count: number }>([REL_TOTAL]),
+    firstThatWorks<{ label: string }>([LABELS]),
+    firstThatWorks<{ relationshipType: string }>([REL_TYPES]),
+    firstThatWorks<{ propertyKey: string }>([PROPERTY_KEYS]),
+    fetchIndexes(),
+    fetchConstraints(),
+  ]);
+  const releaseNumber = release[0]?.releaseNumber;
+  return {
+    neo4jVersion: components[0]?.versions?.[0] ?? null,
+    neo4jEdition: components[0]?.edition ?? null,
+    database: database[0]?.name ?? null,
+    ...(typeof releaseNumber === "number" || typeof releaseNumber === "string"
+      ? { releaseNumber }
+      : {}),
+    nodeCount: Number(nodeTotal[0]?.count ?? 0),
+    relCount: Number(relTotal[0]?.count ?? 0),
+    labelsDigest: digestNames(labels.map(r => r.label)),
+    relationshipTypesDigest: digestNames(relTypes.map(r => r.relationshipType)),
+    propertyKeysDigest: digestNames(propertyKeys.map(r => r.propertyKey)),
+    indexesDigest: digestIndexes(indexes),
+    constraintsDigest: digestConstraints(constraints),
+    generatedAt: new Date().toISOString(),
+  };
+}
+
 async function fetchStats(): Promise<GraphSchema["stats"]> {
   const [labelRows, relRows, nodeTotal, relTotal] = await Promise.all([
-    firstThatWorks<{ label: string }>(["CALL db.labels() YIELD label RETURN label"]),
-    firstThatWorks<{ relationshipType: string }>([
-      "CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType",
-    ]),
-    firstThatWorks<{ count: number }>(["MATCH (n) RETURN count(n) AS count"]),
-    firstThatWorks<{ count: number }>(["MATCH ()-[r]->() RETURN count(r) AS count"]),
+    firstThatWorks<{ label: string }>([LABELS]),
+    firstThatWorks<{ relationshipType: string }>([REL_TYPES]),
+    firstThatWorks<{ count: number }>([NODE_TOTAL]),
+    firstThatWorks<{ count: number }>([REL_TOTAL]),
   ]);
   const [labels, relTypesCount] = await Promise.all([
     countEach(
@@ -220,10 +316,8 @@ async function fetchPatterns(): Promise<GraphSchema["patterns"]> {
 }
 
 const SECTIONS: { [K in Section]: () => Promise<GraphSchema[K]> } = {
-  dbComponents: () =>
-    firstThatWorks([
-      "CALL dbms.components() YIELD name, versions, edition RETURN name, versions, edition",
-    ]),
+  source: fetchSourceFingerprint,
+  dbComponents: () => firstThatWorks([COMPONENTS]),
   stats: fetchStats,
   patterns: fetchPatterns,
   nodeTypeProperties: () =>
@@ -240,19 +334,13 @@ const SECTIONS: { [K in Section]: () => Promise<GraphSchema[K]> } = {
       .filter(r => r.propertyName != null)
       .map(r => ({ ...r, relType: bareRelType(r.relType) }));
   },
-  indexes: () =>
-    firstThatWorks([
-      "SHOW INDEXES YIELD name, type, entityType, labelsOrTypes, properties, state RETURN name, type, entityType, labelsOrTypes, properties, state",
-      "CALL db.indexes() YIELD name, type, entityType, labelsOrTypes, properties, state RETURN name, type, entityType, labelsOrTypes, properties, state",
-    ]),
-  constraints: () =>
-    firstThatWorks([
-      "SHOW CONSTRAINTS YIELD name, type, entityType, labelsOrTypes, properties RETURN name, type, entityType, labelsOrTypes, properties",
-      "CALL db.constraints() YIELD name, description RETURN name, description",
-    ]),
+  indexes: fetchIndexes,
+  constraints: fetchConstraints,
 };
 
 const EMPTY: Omit<GraphSchema, "fetchedAt" | "unavailable"> = {
+  schemaFormat: SCHEMA_FORMAT,
+  source: null,
   dbComponents: [],
   stats: { nodeCount: 0, relCount: 0, labels: {}, relTypesCount: {} },
   patterns: [],
@@ -273,8 +361,17 @@ const EMPTY: Omit<GraphSchema, "fetchedAt" | "unavailable"> = {
  * A fetch in which **no** section could be read -- the database is down, the
  * credentials are wrong -- throws and is not cached, so the next call tries
  * again instead of serving an empty schema.
+ *
+ * With `NEO4J_SCHEMA_FILE` set, the first fetch tries that file before
+ * extracting: it is served only if the live fingerprint matches the one it
+ * was saved with. Anything else is logged, naming why, and the schema is
+ * extracted as though no file were set.
+ *
+ * Asks the gate first, so with graph access off neither the database nor the
+ * file is touched.
  */
 export async function fetchGraphSchema(): Promise<GraphSchema> {
+  if (!isGraphAccessEnabled()) throw new Error(GRAPH_ACCESS_OFF);
   if (schemaCache) {
     const { schema, at } = schemaCache;
     if (schema.unavailable.length === 0) return schema;
@@ -286,6 +383,20 @@ export async function fetchGraphSchema(): Promise<GraphSchema> {
   const start = Date.now();
   schemaPending = (async () => {
     try {
+      const file = previous ? undefined : neo4jSchemaFile();
+      const saved = file ? await matchingSnapshot(file) : null;
+      if (saved) {
+        logger.info("graph schema served from file", {
+          file,
+          durationMs: Date.now() - start,
+          releaseNumber: saved.source?.releaseNumber ?? null,
+          database: saved.source?.database ?? null,
+          nodeCount: saved.stats.nodeCount,
+        });
+        schemaCache = { schema: saved, at: Date.now() };
+        return saved;
+      }
+
       const names = previous
         ? previous.unavailable.map(u => u.section as Section)
         : (Object.keys(SECTIONS) as Section[]);
@@ -328,6 +439,30 @@ export async function fetchGraphSchema(): Promise<GraphSchema> {
   return schemaPending;
 }
 
+/**
+ * The schema saved in `file`, if it describes the database this server is
+ * pointed at; otherwise null, with a warning that says why not. A database
+ * that cannot be fingerprinted is not a match: unverified, the file could be
+ * describing anything.
+ */
+async function matchingSnapshot(file: string): Promise<GraphSchema | null> {
+  try {
+    const saved = parseSchemaSnapshot(await readFile(file, "utf8"));
+    const live = await fetchSourceFingerprint();
+    const differences = sourceMismatches(saved.source, live);
+    if (differences.length > 0) {
+      throw new Error(`it describes a different database (${differences.join("; ")})`);
+    }
+    return saved;
+  } catch (error) {
+    logger.warn("NEO4J_SCHEMA_FILE not used; extracting the schema from the database", {
+      file,
+      reason: message(error),
+    });
+    return null;
+  }
+}
+
 /** For tests -- clears both the cached value and any in-flight fetch. */
 export function _resetGraphSchemaCache(): void {
   schemaCache = null;
diff --git a/src/graph/warmup.ts b/src/graph/warmup.ts
index 360f4ca..00517c9 100644
--- a/src/graph/warmup.ts
+++ b/src/graph/warmup.ts
@@ -15,7 +15,11 @@ import { GRAPH_GROUP, resolveToolGroups } from "../tools/index.js";
  * The decision lives here rather than at each call site, so every entrypoint
  * makes the same one.
  */
+let warmupCalls = 0;
+let warmupPending: Promise<void> | null = null;
+
 export function warmGraphSchema(): void {
+  warmupCalls++;
   let offered: boolean;
   try {
     offered = resolveToolGroups().includes(GRAPH_GROUP);
@@ -35,9 +39,26 @@ export function warmGraphSchema(): void {
     return;
   }
 
-  fetchGraphSchema().catch((error: unknown) => {
-    logger.warn("graph schema warm-up failed; will retry on first use", {
-      error: error instanceof Error ? error.message : String(error),
+  const pending: Promise<void> = fetchGraphSchema()
+    .then(() => undefined)
+    .catch((error: unknown) => {
+      logger.warn("graph schema warm-up failed; will retry on first use", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    })
+    .finally(() => {
+      if (warmupPending === pending) warmupPending = null;
     });
-  });
+  warmupPending = pending;
+}
+
+/**
+ * For tests: how many times an entrypoint has asked for the warm-up, and the
+ * warm-up still running, if one is. Entrypoints start it without waiting, so
+ * a test that asserts on what it did must wait for exactly this rather than
+ * for a fixed time -- on a busy machine a fixed time is too short, and the
+ * work lands in whichever test runs next. The promise never rejects.
+ */
+export function _graphSchemaWarmup(): { calls: number; pending: Promise<void> | null } {
+  return { calls: warmupCalls, pending: warmupPending };
 }
diff --git a/src/index.ts b/src/index.ts
index c0fea30..90387fc 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -22,9 +22,26 @@ async function main() {
   warmGraphSchema();
 }
 
-main().catch(error => {
-  logger.error("fatal error during startup", {
-    error: error instanceof Error ? error.message : String(error),
+if (process.argv[2] === "extract-schema") {
+  // An operator command, not the server: no server is built and no transport
+  // opened. `process.exitCode` rather than `process.exit()`, so the JSON
+  // written to stdout drains before the process ends.
+  import("./cli/extract-schema.js")
+    .then(({ runExtractSchema }) => runExtractSchema(process.argv.slice(3)))
+    .then(code => {
+      process.exitCode = code;
+    })
+    .catch((error: unknown) => {
+      logger.error("extract-schema failed", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      process.exitCode = 1;
+    });
+} else {
+  main().catch(error => {
+    logger.error("fatal error during startup", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    process.exit(1);
   });
-  process.exit(1);
-});
+}
diff --git a/src/tools/cypher.ts b/src/tools/cypher.ts
index 830ab2d..c609df6 100644
--- a/src/tools/cypher.ts
+++ b/src/tools/cypher.ts
@@ -163,7 +163,7 @@ export function registerCypherTools(server: McpServer) {
 
   server.tool(
     "reactome_cypher_schema",
-    "Introspect the Reactome graph schema: labels and relationship types with counts, which labels each relationship type connects, property names and types with mandatory flags, indexes and constraints. Read live from Neo4j's built-in schema procedures and cached for the life of the server (the server warms it at startup; a cold first call can take tens of seconds). Call this before writing Cypher. Sections the database could not provide are listed as unavailable rather than shown empty. For the full JSON, read the `reactome://graph/schema` resource.",
+    "Introspect the Reactome graph schema: labels and relationship types with counts, which labels each relationship type connects, property names and types with mandatory flags, indexes and constraints. Read live from Neo4j's built-in schema procedures and cached for the life of the server (the server warms it at startup; a cold first call can take tens of seconds), or taken from a schema file the operator saved from this same database -- never one saved from another. Call this before writing Cypher. Sections the database could not provide are listed as unavailable rather than shown empty. For the full JSON, read the `reactome://graph/schema` resource.",
     {},
     async () => {
       logger.info("cypher_schema");
diff --git a/tests/extract-schema-cli.test.ts b/tests/extract-schema-cli.test.ts
new file mode 100644
index 0000000..80ed55d
--- /dev/null
+++ b/tests/extract-schema-cli.test.ts
@@ -0,0 +1,278 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { FakeNeo4jState } from "./helpers/fake-neo4j.js";
+
+/**
+ * `reactome-mcp extract-schema`: the server's own extractor, run once against
+ * a database named on the command line, written out as JSON.
+ *
+ * It is an operator tool run by hand, not an instance: it serves nothing, so
+ * it does not ask for MCP_ALLOW_CYPHER. It still reads only, under the same
+ * timeouts as the server, and it never takes a password as an argument --
+ * anything on a command line is visible to every user of the machine in `ps`.
+ */
+
+const fake = vi.hoisted((): FakeNeo4jState => ({ drivers: [], sessions: [], respond: () => [] }));
+
+vi.mock("neo4j-driver", async () => {
+  const { fakeNeo4jModule } = await import("./helpers/fake-neo4j.js");
+  return fakeNeo4jModule(fake);
+});
+
+import { queriesRun } from "./helpers/fake-neo4j.js";
+import { community44 } from "./helpers/community44.js";
+import { runExtractSchema } from "../src/cli/extract-schema.js";
+import { fetchGraphSchema, _resetGraphSchemaCache } from "../src/graph/schema.js";
+import { SCHEMA_FORMAT } from "../src/graph/schema-source.js";
+import { closeDriver } from "../src/clients/neo4j.js";
+
+const URI = "bolt://127.0.0.1:7687";
+const ENV_KEYS = [
+  "NEO4J_URI",
+  "MCP_ALLOW_CYPHER",
+  "NEO4J_USER",
+  "NEO4J_PASSWORD",
+  "NEO4J_DATABASE",
+  "NEO4J_SCHEMA_FILE",
+  "SNAPSHOT_PW",
+];
+
+let saved: Record<string, string | undefined>;
+let dir: string;
+let out: string[];
+let err: string[];
+
+const io = () => ({ stdout: (s: string) => out.push(s), stderr: (s: string) => err.push(s) });
+const run = (...args: string[]) => runExtractSchema(args, io());
+
+/** Timestamps differ between two extractions of the same database. */
+function untimed(schema: Record<string, unknown>) {
+  const source = schema.source as Record<string, unknown>;
+  return { ...schema, fetchedAt: "T", source: { ...source, generatedAt: "T" } };
+}
+
+describe("reactome-mcp extract-schema", () => {
+  beforeEach(() => {
+    saved = Object.fromEntries(ENV_KEYS.map(k => [k, process.env[k]]));
+    for (const k of ENV_KEYS) delete process.env[k];
+    fake.drivers.length = 0;
+    fake.sessions.length = 0;
+    fake.respond = community44();
+    _resetGraphSchemaCache();
+    dir = mkdtempSync(join(tmpdir(), "extract-schema-"));
+    out = [];
+    err = [];
+  });
+
+  afterEach(async () => {
+    _resetGraphSchemaCache();
+    await closeDriver();
+    rmSync(dir, { recursive: true, force: true });
+    for (const [k, v] of Object.entries(saved)) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  });
+
+  it("writes what the server's extractor produces, with the source fingerprint", async () => {
+    const file = join(dir, "reactome-97-schema.json");
+    expect(await run("--uri", URI, "--out", file)).toBe(0);
+    const written = JSON.parse(readFileSync(file, "utf8"));
+
+    expect(written.schemaFormat).toBe(SCHEMA_FORMAT);
+    expect(written.source).toMatchObject({
+      neo4jVersion: "4.4.40",
+      neo4jEdition: "community",
+      releaseNumber: 97,
+      nodeCount: 3_000_000,
+      relCount: 12_000_000,
+    });
+    expect(written.unavailable).toEqual([]);
+
+    // One extractor: the same code, in the server, gives the same structure.
+    _resetGraphSchemaCache();
+    await closeDriver();
+    process.env.NEO4J_URI = URI;
+    process.env.MCP_ALLOW_CYPHER = "1";
+    const served = JSON.parse(JSON.stringify(await fetchGraphSchema()));
+    expect(untimed(written)).toEqual(untimed(served));
+    expect(out.join("")).toBe("");
+  });
+
+  it("writes to stdout when no --out is given, and nothing else there", async () => {
+    expect(await run("--uri", URI)).toBe(0);
+    const parsed = JSON.parse(out.join(""));
+    expect(parsed.source.releaseNumber).toBe(97);
+  });
+
+  it("omits the release for a database without a DBInfo node", async () => {
+    fake.respond = community44({ DBInfo: () => [] });
+    expect(await run("--uri", URI)).toBe(0);
+    const parsed = JSON.parse(out.join(""));
+    expect(parsed.source).not.toHaveProperty("releaseNumber");
+    expect(parsed.source.nodeCount).toBe(3_000_000);
+  });
+
+  it("does not need MCP_ALLOW_CYPHER or NEO4J_URI in the environment", async () => {
+    expect(process.env.MCP_ALLOW_CYPHER).toBeUndefined();
+    expect(await run("--uri", URI)).toBe(0);
+    expect(fake.drivers.map(d => d.uri)).toEqual([URI]);
+  });
+
+  it("reads only, under a timeout, against the database named", async () => {
+    expect(await run("--uri", URI, "--database", "release97", "--user", "reader")).toBe(0);
+    expect(fake.sessions.length).toBeGreaterThan(0);
+    for (const s of fake.sessions) {
+      expect(s.config.defaultAccessMode).toBe("READ");
+      expect(s.config.database).toBe("release97");
+      for (const r of s.runs) expect(r.config?.timeout).toBeGreaterThan(0);
+    }
+  });
+
+  it("always extracts, even with NEO4J_SCHEMA_FILE inherited from the environment", async () => {
+    // Otherwise a matching snapshot would be copied rather than regenerated.
+    // A snapshot that matches this database, so the server would serve it.
+    expect(await run("--uri", URI)).toBe(0);
+    const matching = join(dir, "matching.json");
+    writeFileSync(matching, out.join(""));
+    _resetGraphSchemaCache();
+    await closeDriver();
+    fake.sessions.length = 0;
+    out = [];
+
+    process.env.NEO4J_SCHEMA_FILE = matching;
+    expect(await run("--uri", URI)).toBe(0);
+    expect(queriesRun(fake).some(q => q.includes("db.schema.nodeTypeProperties"))).toBe(true);
+  });
+
+  describe("passwords", () => {
+    it.each([["--password", "hunter2"], ["--password=hunter2"], ["-p", "hunter2"]])(
+      "refuses a password on the command line: %s",
+      async (...flag) => {
+        expect(await run("--uri", URI, ...flag)).toBe(2);
+        expect(err.join("")).toMatch(/environment/i);
+        expect(err.join("")).not.toContain("hunter2");
+        expect(fake.drivers).toHaveLength(0);
+      }
+    );
+
+    it("reads NEO4J_PASSWORD from the environment", async () => {
+      process.env.NEO4J_PASSWORD = "from-env";
+      expect(await run("--uri", URI, "--user", "reader")).toBe(0);
+      expect(fake.drivers[0]?.auth).toEqual({
+        scheme: "basic",
+        principal: "reader",
+        credentials: "from-env",
+      });
+    });
+
+    it("reads the variable --password-env names", async () => {
+      process.env.NEO4J_PASSWORD = "not-this-one";
+      process.env.SNAPSHOT_PW = "this-one";
+      expect(await run("--uri", URI, "--password-env", "SNAPSHOT_PW")).toBe(0);
+      expect(fake.drivers[0]?.auth).toMatchObject({ credentials: "this-one" });
+    });
+
+    it("refuses a --password-env that names an unset variable", async () => {
+      // Connecting without credentials instead would hide the typo.
+      expect(await run("--uri", URI, "--password-env", "SNAPSHOT_PW")).toBe(2);
+      expect(err.join("")).toContain("SNAPSHOT_PW");
+      expect(fake.drivers).toHaveLength(0);
+    });
+  });
+
+  it.each([
+    [[], /--uri/],
+    [["--uri"], /--uri/],
+    [["--uri", URI, "--bogus"], /--bogus/],
+    [["--uri", URI, "--out"], /--out/],
+  ])("refuses %j with usage, connecting to nothing", async (args, message) => {
+    expect(await run(...args)).toBe(2);
+    expect(err.join("")).toMatch(message);
+    expect(fake.drivers).toHaveLength(0);
+  });
+
+  describe("never echoes a value it was given", () => {
+    // Usage errors go to a terminal, a CI log, a ticket. A mistyped flag is
+    // most likely a mistyped --password, and its value the password.
+    it.each([
+      [["--uri", URI, "--passwd=hunter2"], "--passwd"],
+      [["--uri", URI, "--passwd", "hunter2"], "--passwd"],
+      [["--uri", URI, "--user", "neo4j", "hunter2"], "unexpected value"],
+      [["hunter2", "--uri", URI], "unexpected value"],
+      [["--uri", URI, "--password-env", "hunter2!"], "not a valid environment variable name"],
+      [["--uri", URI, "--password-env=hunter 2"], "not a valid environment variable name"],
+    ])("%j", async (args, said) => {
+      expect(await run(...args)).toBe(2);
+      expect(err.join("")).toContain(said);
+      expect(err.join("")).not.toContain("hunter");
+      expect(fake.drivers).toHaveLength(0);
+    });
+
+    it("names a well-formed --password-env variable that is unset", async () => {
+      expect(await run("--uri", URI, "--password-env", "SNAPSHOT_PW")).toBe(2);
+      expect(err.join("")).toContain("SNAPSHOT_PW");
+    });
+  });
+
+  it("refuses to write a schema of a database that changed while it was read", async () => {
+    // The fingerprint and the body are read by separate queries; a curator
+    // writing meanwhile makes them disagree, and the server would refuse the
+    // file. Better to say so now.
+    let calls = 0;
+    fake.respond = community44({
+      "MATCH (n) RETURN count(n)": () => [{ count: 3_000_000 + calls++ }],
+    });
+    const file = join(dir, "schema.json");
+    expect(await run("--uri", URI, "--out", file)).toBe(1);
+    expect(existsSync(file)).toBe(false);
+    expect(err.join("")).toMatch(/changed|disagree/i);
+    expect(err.join("")).toContain("nodeCount");
+  });
+
+  it("prints usage for --help and connects to nothing", async () => {
+    expect(await run("--help")).toBe(0);
+    expect(out.join("")).toContain("--password-env");
+    expect(fake.drivers).toHaveLength(0);
+  });
+
+  it("refuses to write an incomplete schema", async () => {
+    // A snapshot is served for as long as the database matches; one with a
+    // section missing would stay missing for all that time.
+    fake.respond = community44({
+      "db.schema.nodeTypeProperties": () => {
+        throw new Error("The transaction has been terminated (timeout)");
+      },
+    });
+    const file = join(dir, "schema.json");
+    expect(await run("--uri", URI, "--out", file)).toBe(1);
+    expect(existsSync(file)).toBe(false);
+    expect(err.join("")).toContain("nodeTypeProperties");
+  });
+
+  it("leaves no shutdown listeners behind, however many times a driver is built", async () => {
+    // Each build added SIGINT, SIGTERM and beforeExit listeners and nothing
+    // removed them, so a process that closes and reconnects -- this CLI run
+    // twice, the tests -- piled them up past Node's leak warning.
+    const before = process.listenerCount("SIGINT");
+    const beforeExit = process.listenerCount("beforeExit");
+    for (let i = 0; i < 12; i++) {
+      _resetGraphSchemaCache();
+      expect(await run("--uri", URI)).toBe(0);
+    }
+    expect(process.listenerCount("SIGINT")).toBeLessThanOrEqual(before + 1);
+    expect(process.listenerCount("beforeExit")).toBeLessThanOrEqual(beforeExit + 1);
+  });
+
+  it("fails, writing nothing, when the database does not answer", async () => {
+    fake.respond = () => {
+      throw new Error("Could not perform discovery. No routing servers available.");
+    };
+    const file = join(dir, "schema.json");
+    expect(await run("--uri", URI, "--out", file)).toBe(1);
+    expect(existsSync(file)).toBe(false);
+    expect(err.join("")).toMatch(/schema/i);
+  });
+});
diff --git a/tests/graph-access-gate.test.ts b/tests/graph-access-gate.test.ts
index 6a991d3..873e03b 100644
--- a/tests/graph-access-gate.test.ts
+++ b/tests/graph-access-gate.test.ts
@@ -1,5 +1,6 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { describe, it, expect, vi, beforeEach, afterEach, afterAll } from "vitest";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join, relative } from "node:path";
 import type { AddressInfo } from "node:net";
 import type { FakeNeo4jState } from "./helpers/fake-neo4j.js";
@@ -22,6 +23,7 @@ import type { FakeNeo4jState } from "./helpers/fake-neo4j.js";
  */
 
 const fake = vi.hoisted((): FakeNeo4jState => ({ drivers: [], sessions: [], respond: () => [] }));
+const SLOW_DRIVER_LOAD_MS = 60;
 
 /**
  * Registered per test, after `vi.resetModules()`, rather than once with
@@ -33,8 +35,41 @@ const fake = vi.hoisted((): FakeNeo4jState => ({ drivers: [], sessions: [], resp
 function mockDriverModule() {
   vi.doMock("neo4j-driver", async () => {
     const { fakeNeo4jModule } = await import("./helpers/fake-neo4j.js");
+    // Loaded slowly on purpose, as it is on a busy CI runner: a test that
+    // asserts after a fixed wait instead of after the work it started has
+    // finished fails here every time, rather than once in a while in CI.
+    await new Promise(resolve => setTimeout(resolve, SLOW_DRIVER_LOAD_MS));
     return fakeNeo4jModule(fake);
   });
+  mockFileReads();
+}
+
+/**
+ * A schema snapshot named by NEO4J_SCHEMA_FILE in every case below. With the
+ * gate closed it must not even be read: the file describes the graph, and an
+ * instance without graph access has no business with it.
+ */
+const SNAPSHOT_DIR = mkdtempSync(join(tmpdir(), "gate-snapshot-"));
+const SNAPSHOT = join(SNAPSHOT_DIR, "schema.json");
+writeFileSync(SNAPSHOT, JSON.stringify({ schemaFormat: 1 }));
+afterAll(() => rmSync(SNAPSHOT_DIR, { recursive: true, force: true }));
+
+const fileReads = vi.hoisted(() => [] as string[]);
+const snapshotReads = () => fileReads.filter(f => f === SNAPSHOT).length;
+
+/** Count reads through node:fs/promises, re-registered per test like the driver. */
+function mockFileReads() {
+  vi.doMock("node:fs/promises", async importOriginal => {
+    const actual = await importOriginal<typeof import("node:fs/promises")>();
+    const readFile = ((...args: Parameters<typeof actual.readFile>) => {
+      const [path] = args;
+      fileReads.push(
+        typeof path === "string" ? path : path instanceof URL ? path.pathname : "(file handle)"
+      );
+      return actual.readFile(...args);
+    }) as typeof actual.readFile;
+    return { ...actual, default: { ...actual, readFile }, readFile };
+  });
 }
 
 // The stdio entrypoint connects a transport on import. This one talks to
@@ -51,8 +86,33 @@ vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
   },
 }));
 
+/**
+ * Each test gets a fresh copy of the driver module (vi.resetModules), and each
+ * copy hooks process shutdown once. In a real process there is one copy; here
+ * the hooks are removed after every test so they do not pile up across them.
+ */
+const SHUTDOWN_EVENTS = ["SIGINT", "SIGTERM", "beforeExit"] as const;
+let shutdownListeners: Map<string, unknown[]>;
+beforeEach(() => {
+  shutdownListeners = new Map(SHUTDOWN_EVENTS.map(e => [e, process.listeners(e)]));
+});
+afterEach(() => {
+  for (const event of SHUTDOWN_EVENTS) {
+    const before = shutdownListeners.get(event) ?? [];
+    for (const listener of process.listeners(event)) {
+      if (!before.includes(listener)) process.removeListener(event, listener);
+    }
+  }
+});
+
 const URI = "bolt://127.0.0.1:7687";
-const GRAPH_VARS = ["NEO4J_URI", "MCP_ALLOW_CYPHER", "MCP_TOOL_GROUPS", "MCP_HTTP_PORT"] as const;
+const GRAPH_VARS = [
+  "NEO4J_URI",
+  "MCP_ALLOW_CYPHER",
+  "MCP_TOOL_GROUPS",
+  "MCP_HTTP_PORT",
+  "NEO4J_SCHEMA_FILE",
+] as const;
 
 interface GateCase {
   name: string;
@@ -105,11 +165,46 @@ function resetFake() {
   fake.sessions.length = 0;
   fake.respond = () => [];
   fake.moduleLoads = 0;
+  fileReads.length = 0;
 }
 
-/** Let fire-and-forget startup work (the schema warm-up) run to completion. */
-async function settle() {
-  for (let i = 0; i < 5; i++) await new Promise(resolve => setTimeout(resolve, 5));
+/**
+ * Wait until the entrypoint imported in this test has asked for the schema
+ * warm-up, and that warm-up -- if it started one -- has finished. Waits for
+ * the work itself, not for a length of time: a fixed wait passed locally and
+ * failed under load in CI, where the warm-up's driver build landed in the
+ * next test. Bounded, so a startup that never gets there fails here.
+ *
+ * Imported after the entrypoint, from the same module registry, so it is the
+ * entrypoint's own copy of the warm-up module.
+ */
+async function startupSettled() {
+  const { _graphSchemaWarmup } = await import("../src/graph/warmup.js");
+  await vi.waitFor(
+    () => {
+      if (_graphSchemaWarmup().calls === 0) throw new Error("the entrypoint has not started up");
+    },
+    { timeout: 5_000, interval: 5 }
+  );
+  await _graphSchemaWarmup().pending;
+}
+
+/**
+ * Run after every test, before its modules are dropped: a warm-up still
+ * running would finish during the next test and be counted there. One left
+ * behind is awaited -- so it cannot leak -- and then fails the test that
+ * left it.
+ */
+async function noWarmupLeftRunning() {
+  const { _graphSchemaWarmup } = await import("../src/graph/warmup.js");
+  const { closeDriver } = await import("../src/clients/neo4j.js");
+  const { pending } = _graphSchemaWarmup();
+  if (pending) {
+    await pending;
+    await closeDriver();
+    throw new Error("the test ended with a schema warm-up still running");
+  }
+  await closeDriver();
 }
 
 const cypherNames = (names: string[]) => names.filter(n => n.startsWith("reactome_cypher"));
@@ -134,16 +229,20 @@ function recordingServer() {
 
 describe.each(CASES)("graph access gate: $name", ({ env, open }) => {
   beforeEach(() => {
-    applyEnv(env);
+    applyEnv({ ...env, NEO4J_SCHEMA_FILE: SNAPSHOT });
     resetFake();
     vi.resetModules();
     mockDriverModule();
   });
 
-  afterEach(() => {
-    restoreEnv();
-    vi.doUnmock("../src/http.js");
-    vi.resetModules();
+  afterEach(async () => {
+    try {
+      await noWarmupLeftRunning();
+    } finally {
+      restoreEnv();
+      vi.doUnmock("../src/http.js");
+      vi.resetModules();
+    }
   });
 
   it(`the shared predicate reports ${open ? "open" : "closed"}`, async () => {
@@ -180,6 +279,7 @@ describe.each(CASES)("graph access gate: $name", ({ env, open }) => {
 
     // Building a server is not a reason to connect: the driver is lazy.
     expect(fake.drivers).toHaveLength(0);
+    expect(snapshotReads()).toBe(0);
   });
 
   it(`registrars given every group explicitly still ${open ? "offer" : "withhold"} graph access`, async () => {
@@ -231,12 +331,28 @@ describe.each(CASES)("graph access gate: $name", ({ env, open }) => {
     }
   });
 
+  it(`fetchGraphSchema, called directly, ${open ? "checks" : "never reads"} the schema file`, async () => {
+    // The warm-up asks the gate before calling it; this is the check inside,
+    // for a caller that does not.
+    const { fetchGraphSchema } = await import("../src/graph/schema.js");
+    const outcome = await fetchGraphSchema().then(
+      () => "served",
+      (error: unknown) => String(error)
+    );
+    expect(snapshotReads()).toBe(open ? 1 : 0);
+    if (!open) expect(outcome).toMatch(/MCP_ALLOW_CYPHER/);
+    expect(fake.drivers).toHaveLength(open ? 1 : 0);
+  });
+
   it(`the stdio entrypoint ${open ? "warms the schema over one driver" : "never constructs a driver"}`, async () => {
     await import("../src/index.js");
-    await settle();
+    await startupSettled();
     expect(fake.drivers).toHaveLength(open ? 1 : 0);
     // A closed instance never loads neo4j-driver at all.
     expect(fake.moduleLoads).toBe(open ? 1 : 0);
+    // Nor reads the schema snapshot; an open one reads it once, to check it
+    // against the database before trusting it.
+    expect(snapshotReads()).toBe(open ? 1 : 0);
     if (open) {
       // The warm-up ran, read-only, on the dedicated graph.
       expect(fake.drivers[0]?.uri).toBe(URI);
@@ -252,9 +368,10 @@ describe.each(CASES)("graph access gate: $name", ({ env, open }) => {
     vi.doMock("../src/http.js", () => ({ startHttpServer: vi.fn(async () => ({})) }));
     process.env.MCP_HTTP_PORT = "4999";
     await import("../src/http-server.js");
-    await settle();
+    await startupSettled();
     expect(fake.drivers).toHaveLength(open ? 1 : 0);
     expect(fake.moduleLoads).toBe(open ? 1 : 0);
+    expect(snapshotReads()).toBe(open ? 1 : 0);
   });
 
   it(`startHttpServer sessions ${open ? "offer" : "withhold"} graph access, and construct no driver`, async () => {
@@ -320,6 +437,7 @@ describe.each(CASES)("graph access gate: $name", ({ env, open }) => {
       // Serving sessions is not a reason to connect, or to load the driver.
       expect(fake.drivers).toHaveLength(0);
       expect(fake.moduleLoads).toBe(0);
+      expect(snapshotReads()).toBe(0);
     } finally {
       await new Promise(resolve => http.close(resolve));
     }
@@ -328,15 +446,24 @@ describe.each(CASES)("graph access gate: $name", ({ env, open }) => {
 
 describe("graph access gate: open, but the cypher group withheld", () => {
   beforeEach(() => {
-    applyEnv({ NEO4J_URI: URI, MCP_ALLOW_CYPHER: "1", MCP_TOOL_GROUPS: "search,pathway" });
+    applyEnv({
+      NEO4J_URI: URI,
+      MCP_ALLOW_CYPHER: "1",
+      MCP_TOOL_GROUPS: "search,pathway",
+      NEO4J_SCHEMA_FILE: SNAPSHOT,
+    });
     resetFake();
     vi.resetModules();
     mockDriverModule();
   });
 
-  afterEach(() => {
-    restoreEnv();
-    vi.resetModules();
+  afterEach(async () => {
+    try {
+      await noWarmupLeftRunning();
+    } finally {
+      restoreEnv();
+      vi.resetModules();
+    }
   });
 
   it("offers nothing graph-shaped and opens no connection for nobody", async () => {
@@ -351,8 +478,9 @@ describe("graph access gate: open, but the cypher group withheld", () => {
     // Without the tools or the resource nothing can read a warmed cache, so
     // the warm-up must not connect.
     await import("../src/index.js");
-    await settle();
+    await startupSettled();
     expect(fake.drivers).toHaveLength(0);
+    expect(snapshotReads()).toBe(0);
   });
 });
 
@@ -378,6 +506,17 @@ describe("graph access gate: structure", () => {
     expect(importers).toEqual(["clients/neo4j.ts"]);
   });
 
+  it("the extract-schema CLI builds no server and registers nothing", () => {
+    // The CLI connects without MCP_ALLOW_CYPHER because it is not an
+    // instance: it runs once, by hand, and serves nothing. That holds only
+    // while it cannot reach a tool, a resource or a transport.
+    const text = readFileSync(new URL("../src/cli/extract-schema.ts", import.meta.url), "utf8");
+    const imports = [...text.matchAll(/from\s+["']([^"']+)["']/g)].map(m => m[1]);
+    expect(imports.filter(i => /server|http|tools|resources|instructions/.test(i ?? ""))).toEqual(
+      []
+    );
+  });
+
   it("keeps neo4j-driver as a declared dependency", () => {
     const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
     expect(pkg.dependencies["neo4j-driver"]).toBeDefined();
@@ -419,3 +558,45 @@ describe("graph access gate: /health reports the gate as it is now", () => {
     }
   });
 });
+
+describe("graph access gate: the extract-schema subcommand", () => {
+  const argv = process.argv;
+
+  beforeEach(() => {
+    applyEnv({});
+    resetFake();
+    vi.resetModules();
+    mockDriverModule();
+  });
+
+  afterEach(() => {
+    process.argv = argv;
+    process.exitCode = undefined;
+    restoreEnv();
+    vi.doUnmock("../src/cli/extract-schema.js");
+    vi.doUnmock("../src/server.js");
+    vi.resetModules();
+  });
+
+  it("runs the CLI instead of the server, and builds no server", async () => {
+    const runExtractSchema = vi.fn(async () => 0);
+    const createServer = vi.fn();
+    vi.doMock("../src/cli/extract-schema.js", () => ({ runExtractSchema }));
+    vi.doMock("../src/server.js", () => ({ createServer }));
+    process.argv = [argv[0] ?? "node", "dist/index.js", "extract-schema", "--help"];
+
+    await import("../src/index.js");
+    // The dispatch is asynchronous; wait for it to finish, not for a time.
+    await vi.waitFor(
+      () => {
+        if (process.exitCode === undefined) throw new Error("extract-schema has not finished");
+      },
+      { timeout: 5_000, interval: 5 }
+    );
+
+    expect(process.exitCode).toBe(0);
+    expect(runExtractSchema).toHaveBeenCalledWith(["--help"]);
+    expect(createServer).not.toHaveBeenCalled();
+    expect(fake.drivers).toHaveLength(0);
+  });
+});
diff --git a/tests/graph-schema-file.test.ts b/tests/graph-schema-file.test.ts
new file mode 100644
index 0000000..a85af6c
--- /dev/null
+++ b/tests/graph-schema-file.test.ts
@@ -0,0 +1,388 @@
+import { describe, it, expect, vi, beforeEach, afterEach, type MockInstance } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { FakeNeo4jState } from "./helpers/fake-neo4j.js";
+import type { GraphSchema } from "../src/graph/schema.js";
+
+/**
+ * `NEO4J_SCHEMA_FILE`: serve a schema extracted earlier instead of paying for
+ * the full extraction at startup -- but only for the database it describes.
+ *
+ * The server reads the file, takes the cheap part of the live fingerprint
+ * (version, release, total counts), and serves the file only if every field
+ * agrees. Anything else -- another release, a database that has changed, an
+ * older file format, a file that is not JSON, or is not there -- is warned
+ * about by name and the schema is extracted live, as if no file were set. A
+ * schema for a different database is never served: it would be read as a
+ * description of this one.
+ */
+
+const fake = vi.hoisted((): FakeNeo4jState => ({ drivers: [], sessions: [], respond: () => [] }));
+
+vi.mock("neo4j-driver", async () => {
+  const { fakeNeo4jModule } = await import("./helpers/fake-neo4j.js");
+  return fakeNeo4jModule(fake);
+});
+
+import { queriesRun } from "./helpers/fake-neo4j.js";
+import { community44 } from "./helpers/community44.js";
+import { fetchGraphSchema, _resetGraphSchemaCache } from "../src/graph/schema.js";
+import { SCHEMA_FORMAT } from "../src/graph/schema-source.js";
+import { closeDriver } from "../src/clients/neo4j.js";
+import { logger } from "../src/logger.js";
+
+/**
+ * What only the full extraction runs. None of it may run when the file is
+ * used. (Token lists, indexes and constraints are part of the fingerprint:
+ * metadata reads, not scans.)
+ */
+const EXPENSIVE = [
+  "db.schema.nodeTypeProperties",
+  "db.schema.relTypeProperties",
+  "db.schema.visualization",
+  "UNION ALL",
+];
+const expensiveRun = () => queriesRun(fake).filter(q => EXPENSIVE.some(e => q.includes(e)));
+
+let dir: string;
+let snapshot: GraphSchema;
+let warn: MockInstance<typeof logger.warn>;
+let info: MockInstance<typeof logger.info>;
+
+/**
+ * A property row that only a file can carry: the scripted database never
+ * reports it. Node properties are neither fingerprinted nor checked against
+ * the fingerprint, so planting it leaves the file valid and matching -- and
+ * whether a served schema has it says, deterministically, whether the file
+ * was served. (Timestamps cannot: a live extraction can finish in the same
+ * millisecond the snapshot was taken.)
+ */
+const PLANTED = "plantedOnlyInTheFile";
+const fromFile = (schema: GraphSchema) =>
+  schema.nodeTypeProperties.some(p => p.propertyName === PLANTED);
+
+/** A snapshot of the scripted database, taken by the extractor itself, marked. */
+async function takeSnapshot(): Promise<GraphSchema> {
+  const schema = structuredClone(await fetchGraphSchema());
+  _resetGraphSchemaCache();
+  fake.sessions.length = 0;
+  schema.nodeTypeProperties.push({
+    nodeType: ":`Pathway`",
+    nodeLabels: ["Pathway"],
+    propertyName: PLANTED,
+    propertyTypes: ["String"],
+    mandatory: false,
+  });
+  return schema;
+}
+
+function writeSnapshot(content: unknown): string {
+  const file = join(dir, "schema.json");
+  writeFileSync(file, typeof content === "string" ? content : JSON.stringify(content));
+  process.env.NEO4J_SCHEMA_FILE = file;
+  return file;
+}
+
+const warnings = () => warn.mock.calls.map(c => JSON.stringify(c));
+
+describe("NEO4J_SCHEMA_FILE", () => {
+  beforeEach(async () => {
+    // Frozen, so the file and a live extraction carry the same timestamps:
+    // nothing below may tell them apart by time. CI once finished a live
+    // extraction in the same millisecond as the snapshot.
+    vi.useFakeTimers({ toFake: ["Date"] });
+    vi.setSystemTime(new Date("2026-10-14T12:00:00.000Z"));
+    process.env.NEO4J_URI = "bolt://127.0.0.1:7687";
+    process.env.MCP_ALLOW_CYPHER = "1";
+    delete process.env.NEO4J_SCHEMA_FILE;
+    fake.drivers.length = 0;
+    fake.sessions.length = 0;
+    fake.respond = community44();
+    _resetGraphSchemaCache();
+    dir = mkdtempSync(join(tmpdir(), "schema-file-"));
+    snapshot = await takeSnapshot();
+    warn = vi.spyOn(logger, "warn");
+    info = vi.spyOn(logger, "info");
+  });
+
+  afterEach(async () => {
+    vi.useRealTimers();
+    warn.mockRestore();
+    info.mockRestore();
+    _resetGraphSchemaCache();
+    await closeDriver();
+    rmSync(dir, { recursive: true, force: true });
+    delete process.env.NEO4J_URI;
+    delete process.env.MCP_ALLOW_CYPHER;
+    delete process.env.NEO4J_SCHEMA_FILE;
+  });
+
+  it("serves a matching file without running the full extraction", async () => {
+    writeSnapshot(snapshot);
+
+    const schema = await fetchGraphSchema();
+
+    expect(schema).toEqual(snapshot);
+    expect(fromFile(schema)).toBe(true);
+    expect(expensiveRun()).toEqual([]);
+    // It did check: the cheap fingerprint queries ran, read-only.
+    const run = queriesRun(fake);
+    expect(run.some(q => q.includes("dbms.components"))).toBe(true);
+    expect(run.some(q => q.includes("DBInfo"))).toBe(true);
+    for (const s of fake.sessions) expect(s.config.defaultAccessMode).toBe("READ");
+    expect(warnings()).toEqual([]);
+    // And says so: which file, for which release, on which database.
+    const served = info.mock.calls.find(([msg]) => /served from file/.test(msg));
+    expect(served?.[1]).toMatchObject({
+      file: expect.stringContaining("schema.json"),
+      releaseNumber: 97,
+      database: "neo4j",
+    });
+
+    // Complete, so cached: a second call runs nothing at all.
+    const before = queriesRun(fake).length;
+    expect(await fetchGraphSchema()).toBe(schema);
+    expect(queriesRun(fake).length).toBe(before);
+  });
+
+  it("serves a file without a release against a database without a DBInfo node", async () => {
+    fake.respond = community44({ DBInfo: () => [] });
+    const curator = await takeSnapshot();
+    expect(curator.source).not.toHaveProperty("releaseNumber");
+    writeSnapshot(curator);
+
+    expect(await fetchGraphSchema()).toEqual(curator);
+    expect(expensiveRun()).toEqual([]);
+  });
+
+  type Case = {
+    name: string;
+    /** Applied to the file, the database, or both. */
+    file?: (s: GraphSchema) => unknown;
+    db?: Parameters<typeof community44>[0];
+    reason: RegExp;
+  };
+
+  const CASES: Case[] = [
+    {
+      name: "a different Reactome release",
+      db: { DBInfo: () => [{ releaseNumber: 98 }] },
+      reason: /releaseNumber/,
+    },
+    {
+      name: "a release in the file where the database has no DBInfo node",
+      db: { DBInfo: () => [] },
+      reason: /releaseNumber/,
+    },
+    {
+      name: "a different node count (the database has changed since)",
+      db: { "MATCH (n) RETURN count(n)": () => [{ count: 3_000_001 }] },
+      reason: /nodeCount/,
+    },
+    {
+      name: "a different relationship count",
+      db: { "MATCH ()-[r]->() RETURN count(r)": () => [{ count: 1 }] },
+      reason: /relCount/,
+    },
+    {
+      name: "a different Neo4j version",
+      db: {
+        "dbms.components": () => [
+          { name: "Neo4j Kernel", versions: ["5.26.0"], edition: "community" },
+        ],
+      },
+      reason: /neo4jVersion/,
+    },
+    // Changes a curator makes that leave both totals as they were.
+    {
+      name: "a new property key (SET n.newProp on an existing node)",
+      db: {
+        "db.propertyKeys": () => [
+          { propertyKey: "stId" },
+          { propertyKey: "dbId" },
+          { propertyKey: "stoichiometry" },
+          { propertyKey: "newProp" },
+        ],
+      },
+      reason: /propertyKeys/,
+    },
+    {
+      name: "a new label",
+      db: { "db.labels": () => [{ label: "Pathway" }, { label: "Reaction" }, { label: "New" }] },
+      reason: /labels/,
+    },
+    {
+      name: "a new relationship type",
+      db: {
+        "db.relationshipTypes": () => [
+          { relationshipType: "hasEvent" },
+          { relationshipType: "input" },
+          { relationshipType: "output" },
+        ],
+      },
+      reason: /relationshipTypes/,
+    },
+    {
+      name: "a new index (CREATE INDEX)",
+      db: {
+        "SHOW INDEXES": () => [
+          {
+            name: "index_pathway_stId",
+            type: "BTREE",
+            entityType: "NODE",
+            labelsOrTypes: ["Pathway"],
+            properties: ["stId"],
+            state: "ONLINE",
+          },
+          {
+            name: "index_new",
+            type: "BTREE",
+            entityType: "NODE",
+            labelsOrTypes: ["Reaction"],
+            properties: ["stId"],
+            state: "ONLINE",
+          },
+        ],
+      },
+      reason: /indexes/,
+    },
+    {
+      name: "an index that is no longer online",
+      db: {
+        "SHOW INDEXES": () => [
+          {
+            name: "index_pathway_stId",
+            type: "BTREE",
+            entityType: "NODE",
+            labelsOrTypes: ["Pathway"],
+            properties: ["stId"],
+            state: "POPULATING",
+          },
+        ],
+      },
+      reason: /indexes/,
+    },
+    {
+      name: "a dropped constraint",
+      db: { "SHOW CONSTRAINTS": () => [] },
+      reason: /constraints/,
+    },
+    {
+      name: "another database on the same server",
+      db: { "db.info": () => [{ name: "curation" }] },
+      reason: /database/,
+    },
+    {
+      name: "a format 1 file, which carried no metadata digests",
+      file: s => ({ ...s, schemaFormat: 1 }),
+      reason: /schemaFormat/,
+    },
+    // Files that disagree with themselves.
+    {
+      name: "stats.nodeCount that disagrees with the fingerprint",
+      file: s => ({ ...s, stats: { ...s.stats, nodeCount: s.stats.nodeCount + 1 } }),
+      reason: /nodeCount/,
+    },
+    {
+      name: "stats.relCount that disagrees with the fingerprint",
+      file: s => ({ ...s, stats: { ...s.stats, relCount: 0 } }),
+      reason: /relCount/,
+    },
+    {
+      name: "a label list that disagrees with the fingerprint",
+      file: s => ({ ...s, stats: { ...s.stats, labels: { ...s.stats.labels, Extra: 1 } } }),
+      reason: /labels/,
+    },
+    {
+      name: "a relationship type list that disagrees with the fingerprint",
+      file: s => ({ ...s, stats: { ...s.stats, relTypesCount: { hasEvent: 9_000 } } }),
+      reason: /relationshipTypes/,
+    },
+    {
+      name: "an index list that disagrees with the fingerprint",
+      file: s => ({ ...s, indexes: [] }),
+      reason: /indexes/,
+    },
+    {
+      name: "a constraint list that disagrees with the fingerprint",
+      file: s => ({ ...s, constraints: [] }),
+      reason: /constraints/,
+    },
+    {
+      name: "a Neo4j version that disagrees with the fingerprint",
+      file: s => ({
+        ...s,
+        dbComponents: [{ name: "Neo4j Kernel", versions: ["5.0.0"], edition: "community" }],
+      }),
+      reason: /neo4jVersion/,
+    },
+    {
+      name: "another schema format",
+      file: s => ({ ...s, schemaFormat: SCHEMA_FORMAT + 1 }),
+      reason: /schemaFormat/,
+    },
+    {
+      name: "no schema format at all (a file from before there was one)",
+      file: ({ schemaFormat: _f, ...rest }) => rest,
+      reason: /schemaFormat/,
+    },
+    {
+      name: "no source fingerprint",
+      file: s => ({ ...s, source: null }),
+      reason: /source/,
+    },
+    {
+      name: "a file that is not JSON",
+      file: () => '{"schemaFormat": 1, "stats": ',
+      reason: /JSON/,
+    },
+    {
+      name: "JSON that is not a schema",
+      file: s => ({ schemaFormat: s.schemaFormat, source: s.source }),
+      reason: /patterns|stats|nodeTypeProperties/,
+    },
+    {
+      name: "a snapshot with unavailable sections",
+      file: s => ({ ...s, unavailable: [{ section: "indexes", reason: "timeout" }] }),
+      reason: /unavailable/,
+    },
+  ];
+
+  it.each(CASES)("falls back to live extraction, with a warning, on $name", async c => {
+    writeSnapshot(c.file ? c.file(snapshot) : snapshot);
+    if (c.db) fake.respond = community44(c.db);
+
+    const schema = await fetchGraphSchema();
+
+    // Extracted live: the expensive procedures ran, and what is served
+    // describes the database that answered, not the file.
+    expect(expensiveRun().length).toBeGreaterThan(0);
+    expect(schema.unavailable).toEqual([]);
+    expect(fromFile(schema)).toBe(false);
+
+    const said = warnings().join("\n");
+    expect(said).toContain("schema.json");
+    expect(said).toMatch(c.reason);
+  });
+
+  it("falls back, with a warning, when the file is not there", async () => {
+    process.env.NEO4J_SCHEMA_FILE = join(dir, "missing.json");
+    const schema = await fetchGraphSchema();
+    expect(expensiveRun().length).toBeGreaterThan(0);
+    expect(fromFile(schema)).toBe(false);
+    expect(schema.unavailable).toEqual([]);
+    expect(warnings().join("\n")).toContain("missing.json");
+  });
+
+  it("never serves the file when the database cannot be fingerprinted", async () => {
+    // Unverifiable is not a match. With the database down, the live
+    // extraction fails too, and that is what the caller hears.
+    writeSnapshot(snapshot);
+    fake.respond = () => {
+      throw new Error("Could not perform discovery. No routing servers available.");
+    };
+    await expect(fetchGraphSchema()).rejects.toThrow(/schema/i);
+    expect(warnings().join("\n")).toContain("schema.json");
+  });
+});
diff --git a/tests/graph-schema.test.ts b/tests/graph-schema.test.ts
index b5a8669..09e5222 100644
--- a/tests/graph-schema.test.ts
+++ b/tests/graph-schema.test.ts
@@ -19,102 +19,16 @@ vi.mock("neo4j-driver", async () => {
 });
 
 import { queriesRun } from "./helpers/fake-neo4j.js";
+import { community44, NO_PROCEDURE } from "./helpers/community44.js";
 import {
   fetchGraphSchema,
   _resetGraphSchemaCache,
   SCHEMA_RETRY_AFTER_MS,
 } from "../src/graph/schema.js";
+import { SCHEMA_FORMAT } from "../src/graph/schema-source.js";
 import { formatGraphSchemaMarkdown } from "../src/graph/format-schema.js";
 import { closeDriver } from "../src/clients/neo4j.js";
 
-const NO_PROCEDURE = (name: string) =>
-  new Error(
-    `There is no procedure with the name \`${name}\` registered for this database instance.`
-  );
-
-/**
- * Answers the way Neo4j 4.4 Community without APOC does. `overrides` replaces
- * the answer for any query containing its key.
- */
-function community44(
-  overrides: Record<string, (params: Record<string, unknown>) => unknown[]> = {}
-) {
-  return (query: string, params: Record<string, unknown>): unknown[] => {
-    for (const [needle, answer] of Object.entries(overrides)) {
-      if (query.includes(needle)) return answer(params);
-    }
-    const apoc = /\b(apoc\.[\w.]+)/.exec(query);
-    if (apoc?.[1]) throw NO_PROCEDURE(apoc[1]);
-
-    if (query.includes("dbms.components"))
-      return [{ name: "Neo4j Kernel", versions: ["4.4.40"], edition: "community" }];
-    if (query.includes("db.labels")) return [{ label: "Pathway" }, { label: "Reaction" }];
-    if (query.includes("db.relationshipTypes"))
-      return [{ relationshipType: "hasEvent" }, { relationshipType: "input" }];
-    if (query.includes("db.schema.nodeTypeProperties"))
-      return [
-        {
-          nodeType: ":`Pathway`",
-          nodeLabels: ["Pathway"],
-          propertyName: "stId",
-          propertyTypes: ["String"],
-          mandatory: true,
-        },
-      ];
-    if (query.includes("db.schema.relTypeProperties"))
-      return [
-        {
-          relType: ":`input`",
-          propertyName: "stoichiometry",
-          propertyTypes: ["Long"],
-          mandatory: true,
-        },
-      ];
-    if (query.includes("db.schema.visualization"))
-      return [
-        {
-          nodes: [
-            { identity: -1, labels: ["Pathway"], properties: { name: "Pathway" } },
-            { identity: -2, labels: ["Reaction"], properties: { name: "Reaction" } },
-          ],
-          relationships: [{ identity: -3, start: -1, end: -2, type: "hasEvent", properties: {} }],
-        },
-      ];
-    if (query.includes("SHOW INDEXES"))
-      return [
-        {
-          name: "index_pathway_stId",
-          type: "BTREE",
-          entityType: "NODE",
-          labelsOrTypes: ["Pathway"],
-          properties: ["stId"],
-          state: "ONLINE",
-        },
-      ];
-    if (query.includes("SHOW CONSTRAINTS"))
-      return [
-        {
-          name: "constraint_dbId",
-          type: "UNIQUENESS",
-          entityType: "NODE",
-          labelsOrTypes: ["DatabaseObject"],
-          properties: ["dbId"],
-        },
-      ];
-    // Per-token counts: one UNION ALL query each for labels and for
-    // relationship types, keyed by parameter so the names need no escaping.
-    if (query.includes("UNION ALL") || /RETURN \$\w+ AS key/.test(query)) {
-      return Object.entries(params).map(([, key]) => ({
-        key,
-        count: key === "Pathway" ? 2_000 : key === "hasEvent" ? 9_000 : 500,
-      }));
-    }
-    if (/MATCH \(n\) RETURN count\(n\)/.test(query)) return [{ count: 3_000_000 }];
-    if (/MATCH \(\)-\[r\]->\(\) RETURN count\(r\)/.test(query)) return [{ count: 12_000_000 }];
-    throw new Error(`unscripted query: ${query}`);
-  };
-}
-
 describe("fetchGraphSchema on Neo4j 4.4 Community without APOC", () => {
   beforeEach(() => {
     process.env.NEO4J_URI = "bolt://127.0.0.1:7687";
@@ -150,6 +64,59 @@ describe("fetchGraphSchema on Neo4j 4.4 Community without APOC", () => {
     expect(schema.constraints[0]?.name).toBe("constraint_dbId");
   });
 
+  it("records which database it describes, and the format it is written in", async () => {
+    // A schema saved to a file is only usable against the database it came
+    // from; the fingerprint is how a reader tells.
+    const schema = await fetchGraphSchema();
+    expect(schema.schemaFormat).toBe(SCHEMA_FORMAT);
+    const digest = expect.stringMatching(/^[0-9a-f]{64}$/);
+    expect(schema.source).toEqual({
+      neo4jVersion: "4.4.40",
+      neo4jEdition: "community",
+      database: "neo4j",
+      releaseNumber: 97,
+      nodeCount: 3_000_000,
+      relCount: 12_000_000,
+      labelsDigest: digest,
+      relationshipTypesDigest: digest,
+      propertyKeysDigest: digest,
+      indexesDigest: digest,
+      constraintsDigest: digest,
+      generatedAt: expect.any(String),
+    });
+    expect(Number.isNaN(Date.parse(schema.source?.generatedAt ?? ""))).toBe(false);
+  });
+
+  it("is format 2: format 1 files carried no metadata digests", () => {
+    expect(SCHEMA_FORMAT).toBe(2);
+  });
+
+  it("digests each metadata list in a canonical order, so the order the database answers in does not matter", async () => {
+    const first = (await fetchGraphSchema()).source;
+    _resetGraphSchemaCache();
+    fake.respond = community44({
+      "db.labels": () => [{ label: "Reaction" }, { label: "Pathway" }],
+      "db.propertyKeys": () => [
+        { propertyKey: "stoichiometry" },
+        { propertyKey: "dbId" },
+        { propertyKey: "stId" },
+      ],
+    });
+    const second = (await fetchGraphSchema()).source;
+    expect(second?.labelsDigest).toBe(first?.labelsDigest);
+    expect(second?.propertyKeysDigest).toBe(first?.propertyKeysDigest);
+  });
+
+  it("leaves the release out, rather than guessing, where there is no DBInfo node", async () => {
+    // A curator database or a non-Reactome graph has none. That is not a
+    // failure: the rest of the fingerprint still identifies the database.
+    fake.respond = community44({ DBInfo: () => [] });
+    const schema = await fetchGraphSchema();
+    expect(schema.unavailable).toEqual([]);
+    expect(schema.source).not.toHaveProperty("releaseNumber");
+    expect(schema.source?.nodeCount).toBe(3_000_000);
+  });
+
   it("reads only, and under a timeout", async () => {
     await fetchGraphSchema();
     expect(fake.sessions.length).toBeGreaterThan(0);
@@ -203,8 +170,10 @@ describe("fetchGraphSchema on Neo4j 4.4 Community without APOC", () => {
     const schema = await fetchGraphSchema();
     expect(schema.nodeTypeProperties).toEqual([]);
     expect(schema.indexes).toEqual([]);
+    // The fingerprint digests the index list, so without one there is no
+    // fingerprint either -- and no saved schema could be verified against it.
     expect(schema.unavailable.map(u => u.section).sort()).toEqual(
-      ["indexes", "nodeTypeProperties"].sort()
+      ["indexes", "nodeTypeProperties", "source"].sort()
     );
     // The rest is intact.
     expect(schema.stats.labels.Pathway).toBe(2_000);
@@ -294,13 +263,30 @@ describe("fetchGraphSchema on Neo4j 4.4 Community without APOC", () => {
     ]);
     expect(a).toBe(b);
     expect(b).toBe(c);
-    expect(queriesRun(fake).filter(q => q.includes("dbms.components"))).toHaveLength(1);
+    // A query one fetch runs exactly once. (dbms.components runs twice per
+    // fetch: once for the source fingerprint, once for dbComponents.)
+    expect(queriesRun(fake).filter(q => q.includes("db.schema.visualization"))).toHaveLength(1);
   });
 });
 
 function minimalSchema(): GraphSchema {
   return {
+    schemaFormat: SCHEMA_FORMAT,
     fetchedAt: "2026-10-14T15:00:00Z",
+    source: {
+      neo4jVersion: "4.4.40",
+      neo4jEdition: "community",
+      database: "neo4j",
+      releaseNumber: 97,
+      nodeCount: 100,
+      relCount: 200,
+      labelsDigest: "0".repeat(64),
+      relationshipTypesDigest: "0".repeat(64),
+      propertyKeysDigest: "0".repeat(64),
+      indexesDigest: "0".repeat(64),
+      constraintsDigest: "0".repeat(64),
+      generatedAt: "2026-10-14T15:00:00Z",
+    },
     dbComponents: [{ name: "Neo4j Kernel", versions: ["4.4.40"], edition: "community" }],
     stats: {
       nodeCount: 100,
@@ -348,6 +334,7 @@ describe("formatGraphSchemaMarkdown", () => {
   it("covers totals, labels, rel types, patterns, properties, indexes, constraints", () => {
     const md = formatGraphSchemaMarkdown(minimalSchema());
     expect(md).toContain("Neo4j:** 4.4.40");
+    expect(md).toContain("**Reactome release:** 97");
     expect(md).toContain("100 nodes");
     expect(md).toContain("`Pathway` 50");
     expect(md).toContain("`hasEvent` 80");
@@ -362,6 +349,12 @@ describe("formatGraphSchemaMarkdown", () => {
     expect(md.toLowerCase()).not.toContain("apoc");
   });
 
+  it("names no release for a graph that has none", () => {
+    const { releaseNumber: _omitted, ...source } = minimalSchema().source!;
+    const md = formatGraphSchemaMarkdown({ ...minimalSchema(), source });
+    expect(md).not.toContain("Reactome release");
+  });
+
   it("stays small enough for an LLM context window", () => {
     expect(formatGraphSchemaMarkdown(minimalSchema()).length).toBeLessThan(10_000);
   });
diff --git a/tests/helpers/community44.ts b/tests/helpers/community44.ts
new file mode 100644
index 0000000..27b3ebe
--- /dev/null
+++ b/tests/helpers/community44.ts
@@ -0,0 +1,97 @@
+/**
+ * A scripted database that answers the way the Reactome graph database
+ * container does: Neo4j 4.4 Community, no APOC, Release 97 in its DBInfo
+ * node. Hand it to a fake driver as `state.respond`.
+ */
+
+export const NO_PROCEDURE = (name: string) =>
+  new Error(
+    `There is no procedure with the name \`${name}\` registered for this database instance.`
+  );
+
+/**
+ * Answers the way Neo4j 4.4 Community without APOC does. `overrides` replaces
+ * the answer for any query containing its key.
+ */
+export function community44(
+  overrides: Record<string, (params: Record<string, unknown>) => unknown[]> = {}
+) {
+  return (query: string, params: Record<string, unknown>): unknown[] => {
+    for (const [needle, answer] of Object.entries(overrides)) {
+      if (query.includes(needle)) return answer(params);
+    }
+    const apoc = /\b(apoc\.[\w.]+)/.exec(query);
+    if (apoc?.[1]) throw NO_PROCEDURE(apoc[1]);
+
+    if (query.includes("dbms.components"))
+      return [{ name: "Neo4j Kernel", versions: ["4.4.40"], edition: "community" }];
+    if (query.includes("DBInfo")) return [{ releaseNumber: 97 }];
+    if (query.includes("db.info")) return [{ name: "neo4j" }];
+    if (query.includes("db.propertyKeys"))
+      return [{ propertyKey: "stId" }, { propertyKey: "dbId" }, { propertyKey: "stoichiometry" }];
+    if (query.includes("db.labels")) return [{ label: "Pathway" }, { label: "Reaction" }];
+    if (query.includes("db.relationshipTypes"))
+      return [{ relationshipType: "hasEvent" }, { relationshipType: "input" }];
+    if (query.includes("db.schema.nodeTypeProperties"))
+      return [
+        {
+          nodeType: ":`Pathway`",
+          nodeLabels: ["Pathway"],
+          propertyName: "stId",
+          propertyTypes: ["String"],
+          mandatory: true,
+        },
+      ];
+    if (query.includes("db.schema.relTypeProperties"))
+      return [
+        {
+          relType: ":`input`",
+          propertyName: "stoichiometry",
+          propertyTypes: ["Long"],
+          mandatory: true,
+        },
+      ];
+    if (query.includes("db.schema.visualization"))
+      return [
+        {
+          nodes: [
+            { identity: -1, labels: ["Pathway"], properties: { name: "Pathway" } },
+            { identity: -2, labels: ["Reaction"], properties: { name: "Reaction" } },
+          ],
+          relationships: [{ identity: -3, start: -1, end: -2, type: "hasEvent", properties: {} }],
+        },
+      ];
+    if (query.includes("SHOW INDEXES"))
+      return [
+        {
+          name: "index_pathway_stId",
+          type: "BTREE",
+          entityType: "NODE",
+          labelsOrTypes: ["Pathway"],
+          properties: ["stId"],
+          state: "ONLINE",
+        },
+      ];
+    if (query.includes("SHOW CONSTRAINTS"))
+      return [
+        {
+          name: "constraint_dbId",
+          type: "UNIQUENESS",
+          entityType: "NODE",
+          labelsOrTypes: ["DatabaseObject"],
+          properties: ["dbId"],
+        },
+      ];
+    // Per-token counts: one UNION ALL query each for labels and for
+    // relationship types, keyed by parameter so the names need no escaping.
+    if (query.includes("UNION ALL") || /RETURN \$\w+ AS key/.test(query)) {
+      return Object.entries(params).map(([, key]) => ({
+        key,
+        count: key === "Pathway" ? 2_000 : key === "hasEvent" ? 9_000 : 500,
+      }));
+    }
+    if (/MATCH \(n\) RETURN count\(n\)/.test(query)) return [{ count: 3_000_000 }];
+    if (/MATCH \(\)-\[r\]->\(\) RETURN count\(r\)/.test(query)) return [{ count: 12_000_000 }];
+    throw new Error(`unscripted query: ${query}`);
+  };
+}
diff --git a/tests/helpers/fake-neo4j.ts b/tests/helpers/fake-neo4j.ts
index 6210517..e10e26d 100644
--- a/tests/helpers/fake-neo4j.ts
+++ b/tests/helpers/fake-neo4j.ts
@@ -30,7 +30,7 @@ export interface FakeSession {
 export type FakeRows = Iterable<unknown>;
 
 export interface FakeNeo4jState {
-  drivers: Array<{ uri: string; config: Record<string, unknown> }>;
+  drivers: Array<{ uri: string; config: Record<string, unknown>; auth?: unknown }>;
   sessions: FakeSession[];
   /** Rows for a query; throw to simulate a database error. */
   respond: (query: string, params: Record<string, unknown>) => FakeRows | Promise<FakeRows>;
@@ -105,8 +105,8 @@ function fakeResult(state: FakeNeo4jState, run: FakeRun) {
 export function fakeNeo4jModule(state: FakeNeo4jState) {
   state.moduleLoads = (state.moduleLoads ?? 0) + 1;
   const neo4j = {
-    driver(uri: string, _auth: unknown, config: Record<string, unknown> = {}) {
-      state.drivers.push({ uri, config });
+    driver(uri: string, auth: unknown, config: Record<string, unknown> = {}) {
+      state.drivers.push({ uri, config, auth });
       return {
         session(sessionConfig: Record<string, unknown> = {}) {
           const session: FakeSession = { config: sessionConfig, runs: [], closed: false };
@@ -135,7 +135,13 @@ export function fakeNeo4jModule(state: FakeNeo4jState) {
         async close() {},
       };
     },
-    auth: { basic: (user: string, _password: string) => ({ scheme: "basic", principal: user }) },
+    auth: {
+      basic: (user: string, password: string) => ({
+        scheme: "basic",
+        principal: user,
+        credentials: password,
+      }),
+    },
     session: { READ: "READ", WRITE: "WRITE" },
     int: (value: number | string) => ({ __int: Number(value) }),
   };