@descent-vtt/spec-guard 0.11.0 → 0.12.1

package/dist/mcp.js

@@ -2,167 +2,119 @@
  * `spec-guard mcp`: the rules, served to an agent over the Model Context
  * Protocol on stdio.
  *
- * No SDK. MCP over stdio is JSON-RPC 2.0, one message per line, and what a
- * server has to get right fits in this file: framing, the two eras of the
- * protocol, and four methods' worth of results. The official SDK brings a
- * schema library and a dependency tree to do the same, and spec-guard's first
- * invariant is that it has no runtime dependencies at all. ADR-0012 has the
- * rest, including what this file deliberately does not implement.
- *
- * Two eras, served side by side. Revisions up to 2025-11-25 open with an
- * `initialize` handshake; 2026-07-28 has none, and every request carries its
- * protocol version in `_meta`. Clients of both are in use, so each request is
- * classified on its own - by the rule the TypeScript SDK's server applies, not
- * by one invented here: a request that claims a version in `_meta` is modern
- * and its claim is validated; anything else, `initialize` included, is legacy.
+ * No SDK. The protocol - framing, the two eras, classifying each request,
+ * dispatching it and shaping its result - is spec-core's `jsonrpc` module,
+ * copied into `src/vendor` and verified by hash (ADR-0015). It was written
+ * here first and moved there so that a second server in the family does not
+ * relearn it. What is spec-guard's, and stays here, is what the server says:
+ * its instructions, its three tools, and the rules and documents it serves as
+ * resources. ADR-0012 has the rest, including what this server deliberately
+ * does not implement; ADR-0018 has `get_dependents`.
  */
 import { toPosix } from './glob.js';
+import { formatImpact, ImpactError, impactDocument, impactOf } from './impact.js';
 import { nodeIo, readText } from './io.js';
 import { formatReport } from './reporter.js';
 import { elapsed, runSpecGuard } from './runner.js';
 import { answerQuery, formatQuery, inQueriedPaths, loadRuleSet, QueryPathError, resolveQueryPath, viewDocument, } from './query.js';
 import { governs, viewRule } from './rules.js';
-/* ----------------------------------------------------------------- protocol */
-/** Revisions that carry their version on every request. Newest first. */
-export const MODERN_PROTOCOL_VERSIONS = ['2026-07-28'];
-/** Revisions negotiated by `initialize`, newest first - the SDK's own list. */
-export const LEGACY_PROTOCOL_VERSIONS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05', '2024-10-07'];
-export const PROTOCOL_VERSION_KEY = 'io.modelcontextprotocol/protocolVersion';
-export const CLIENT_CAPABILITIES_KEY = 'io.modelcontextprotocol/clientCapabilities';
-export const CLIENT_INFO_KEY = 'io.modelcontextprotocol/clientInfo';
-export const SERVER_INFO_KEY = 'io.modelcontextprotocol/serverInfo';
-export const PARSE_ERROR = -32700;
-export const INVALID_REQUEST = -32600;
-export const METHOD_NOT_FOUND = -32601;
-export const INVALID_PARAMS = -32602;
-export const INTERNAL_ERROR = -32603;
-/** Resource not found before 2026-07-28, which forbids it in favour of -32602. */
-export const LEGACY_RESOURCE_NOT_FOUND = -32002;
-export const UNSUPPORTED_PROTOCOL_VERSION = -32022;
-class ProtocolError extends Error {
-    code;
-    data;
-    constructor(code, message, data) {
-        super(message);
-        this.code = code;
-        this.data = data;
-    }
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/** JSON-RPC allows a null id; MCP does not, and requires an integer if a number. */
-function isRequestId(value) {
-    return typeof value === 'string' || Number.isInteger(value);
-}
-/**
- * What is wrong with a request's `_meta`, once it claims a protocol version.
- *
- * Only what the server depends on or the revision requires: a version that is a
- * string, capabilities that are an object, and client info shaped as client info
- * when it is sent. A claim is never silently ignored - a malformed one is an
- * error, not a reason to fall back to legacy handling.
- */
-export function envelopeIssue(meta) {
-    if (!(CLIENT_CAPABILITIES_KEY in meta))
-        return `${CLIENT_CAPABILITIES_KEY}: missing`;
-    if (typeof meta[PROTOCOL_VERSION_KEY] !== 'string')
-        return `${PROTOCOL_VERSION_KEY}: expected a string`;
-    if (!isObject(meta[CLIENT_CAPABILITIES_KEY]))
-        return `${CLIENT_CAPABILITIES_KEY}: expected an object`;
-    const info = meta[CLIENT_INFO_KEY];
-    if (info !== undefined && !(isObject(info) && typeof info['name'] === 'string' && typeof info['version'] === 'string')) {
-        return `${CLIENT_INFO_KEY}: expected an object with a string name and version`;
-    }
-    return undefined;
-}
-/**
- * The era a request belongs to, or the error that answers it instead.
- *
- * `initialize` is the legacy handshake unless it carries a valid modern claim.
- * Any other request is modern exactly when `_meta` holds the version key - its
- * presence is the claim, whatever its value - and legacy otherwise.
- */
-export function classifyRequest(method, params) {
-    const meta = params?.['_meta'];
-    const claimed = isObject(meta) && PROTOCOL_VERSION_KEY in meta;
-    if (!claimed)
-        return 'legacy';
-    const issue = envelopeIssue(meta);
-    const version = meta[PROTOCOL_VERSION_KEY];
-    const supported = issue === undefined && MODERN_PROTOCOL_VERSIONS.includes(version);
-    if (method === 'initialize' && !supported)
-        return 'legacy';
-    if (issue !== undefined)
-        throw new ProtocolError(INVALID_PARAMS, `Invalid _meta envelope: ${issue}`);
-    if (!supported) {
-        throw new ProtocolError(UNSUPPORTED_PROTOCOL_VERSION, 'Unsupported protocol version', {
-            supported: [...MODERN_PROTOCOL_VERSIONS],
-            requested: version,
-        });
-    }
-    return 'modern';
-}
-/** The version `initialize` settles on: the one asked for, or the newest legacy one. */
-export function negotiateLegacyVersion(requested) {
-    // No typeof check: a list of strings includes nothing that is not one.
-    return LEGACY_PROTOCOL_VERSIONS.includes(requested) ? requested : LEGACY_PROTOCOL_VERSIONS[0];
-}
+import { createDocumentMemo } from './specs.js';
+import { createMcpServer, serveLines, toolError, unknownArguments, } from './vendor/spec-core/jsonrpc/index.js';
+// The protocol's names, re-exported from where they now live, so that a
+// caller of the API who imported them from here still finds them.
+export { classifyRequest, envelopeIssue, negotiateLegacyVersion, CLIENT_CAPABILITIES_KEY, CLIENT_INFO_KEY, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, LEGACY_PROTOCOL_VERSIONS, LEGACY_RESOURCE_NOT_FOUND, METHOD_NOT_FOUND, MODERN_PROTOCOL_VERSIONS, PARSE_ERROR, PROTOCOL_VERSION_KEY, SERVER_INFO_KEY, UNSUPPORTED_PROTOCOL_VERSION, } from './vendor/spec-core/jsonrpc/index.js';
 /* -------------------------------------------------------------- the surface */
 export const SERVER_NAME = 'spec-guard';
 export const INSTRUCTIONS = 'spec-guard enforces the architecture decisions written in this project\'s Markdown specs and ADRs. ' +
     'Before creating or changing a file, call get_architectural_rules with its path to learn the rules in force there: ' +
     'imports it must not make, the layer it belongs to, what it must be named and the files it needs beside it, text it must not contain. ' +
+    'Before changing a file that other files import - renaming or removing an export, changing what a function takes or returns - ' +
+    'call get_dependents with its path to learn every file the change can reach and the rules in force over them. ' +
     'After changing files, call check_architecture with their paths to find violations before CI does. ' +
-    'Rules in draft, proposed, rejected, deprecated or superseded documents are not in force and are only counted.';
+    'Rules in draft, proposed, rejected, deprecated, superseded or archived documents are not in force and are only counted.';
 const READ_ONLY = { readOnlyHint: true, idempotentHint: true, openWorldHint: false };
-export const TOOLS = [
-    {
-        name: 'get_architectural_rules',
-        title: 'Architectural rules for a path',
-        description: 'Lists the architecture rules in force for a file or directory, grouped by the ADR or spec that states them: ' +
-            'modules it must not import, the layer it belongs to and the layers it must not depend on, import cycles, ' +
-            'what it must be named and the partner files it needs, ' +
-            'and text or symbols it must not contain, each with the reason the document gives. ' +
-            'Answers from the specs without reading the codebase, so it works for a file that does not exist yet. ' +
-            'Rules in documents that are not in force are counted and named but not listed unless include_inactive is true.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'A file or directory, relative to the project root or absolute inside it.',
-                },
-                include_inactive: {
-                    type: 'boolean',
-                    description: 'Also list rules from draft, proposed, rejected, deprecated and superseded documents.',
-                },
+const GET_RULES = {
+    name: 'get_architectural_rules',
+    title: 'Architectural rules for a path',
+    description: 'Lists the architecture rules in force for a file or directory, grouped by the ADR or spec that states them: ' +
+        'modules it must not import, the layer it belongs to and the layers it must not depend on, import cycles, ' +
+        'what it must be named and the partner files it needs, ' +
+        'and text or symbols it must not contain, each with the reason the document gives. ' +
+        'Answers from the specs without reading the codebase, so it works for a file that does not exist yet. ' +
+        'Rules in documents that are not in force are counted and named but not listed unless include_inactive is true.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'A file or directory, relative to the project root or absolute inside it.',
+            },
+            include_inactive: {
+                type: 'boolean',
+                description: 'Also list rules from draft, proposed, rejected, deprecated, superseded and archived documents.',
             },
-            required: ['path'],
-            additionalProperties: false,
         },
-        annotations: READ_ONLY,
+        required: ['path'],
+        additionalProperties: false,
     },
-    {
-        name: 'check_architecture',
-        title: 'Check the architecture rules',
-        description: 'Runs the architecture rules in force against the files on disk and reports every violation, as CI would. ' +
-            'Given paths, runs only the rules that govern them - each over its whole scope, so a count or a cycle is judged ' +
-            'exactly as CI judges it - and marks which violations lie in those paths. Save your edits before calling.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                paths: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Files or directories to check the rules of, relative to the project root. Omit to run every rule.',
-                },
+    annotations: READ_ONLY,
+};
+const CHECK_ARCHITECTURE = {
+    name: 'check_architecture',
+    title: 'Check the architecture rules',
+    description: 'Runs the architecture rules in force against the files on disk and reports every violation, as CI would. ' +
+        'Given paths, runs only the rules that govern them - each over its whole scope, so a count or a cycle is judged ' +
+        'exactly as CI judges it - and marks which violations lie in those paths. Save your edits before calling.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            paths: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Files or directories to check the rules of, relative to the project root. Omit to run every rule.',
             },
-            additionalProperties: false,
         },
-        annotations: READ_ONLY,
+        additionalProperties: false,
     },
-];
+    annotations: READ_ONLY,
+};
+const GET_DEPENDENTS = {
+    name: 'get_dependents',
+    title: 'Files that depend on a path',
+    description: 'Lists the files that import each given file or directory, directly or through other files, ' +
+        'each with how many imports away it is and the import that leads there, ' +
+        'and the architecture rules in force that govern the paths or any of those files. ' +
+        'Call it before changing a file that other files import - renaming or removing an export, changing a signature - ' +
+        'to see everything the change can reach. ' +
+        'Relative JavaScript, TypeScript and Python imports are followed; an import that cannot be resolved is listed, ' +
+        'and Go, Rust, C# and absolute Python imports, which name modules rather than files, are counted, never guessed, ' +
+        'so a short list is not mistaken for a complete one. Reads the codebase on disk, so every path must exist.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            paths: {
+                type: 'array',
+                items: { type: 'string' },
+                minItems: 1,
+                description: 'Files or directories that exist, relative to the project root or absolute inside it.',
+            },
+            depth: {
+                type: 'integer',
+                minimum: 1,
+                description: 'Follow dependents at most this many imports away. Omit to follow every one.',
+            },
+            include_inactive: {
+                type: 'boolean',
+                description: 'Also list rules from draft, proposed, rejected, deprecated, superseded and archived documents.',
+            },
+        },
+        required: ['paths'],
+        additionalProperties: false,
+    },
+    annotations: READ_ONLY,
+};
+/** What `tools/list` answers, in the order it lists them. */
+export const TOOLS = [GET_RULES, CHECK_ARCHITECTURE, GET_DEPENDENTS];
 export const RULES_URI = 'spec://rules';
 export const DOCUMENT_URI_PREFIX = 'spec://doc/';
 export const RESOURCE_TEMPLATES = [
@@ -189,15 +141,24 @@ export function documentPath(uri) {
         return null;
     }
 }
-function toolError(text) {
-    return { text, isError: true };
-}
-/** Arguments a tool does not declare, which the model should hear about. */
-function unknownArguments(args, allowed) {
-    const unknown = Object.keys(args).filter((name) => !allowed.includes(name));
-    return unknown.length === 0
-        ? undefined
-        : toolError(`Unknown argument${unknown.length === 1 ? '' : 's'} ${unknown.map((name) => `"${name}"`).join(', ')}; this tool takes ${allowed.join(' and ')}.`);
+/**
+ * One of the server's tools.
+ *
+ * A path argument outside the root, or one that must exist and does not, is
+ * the model's to fix, so it hears the message alone. Anything else a tool
+ * throws is caught by the protocol layer and reported after the server's name,
+ * "spec-guard failed: ...", which is still better than a protocol failure the
+ * model cannot read.
+ */
+function tool(descriptor, run) {
+    return {
+        descriptor,
+        call: (args) => run(args).catch((error) => {
+            if (error instanceof QueryPathError || error instanceof ImpactError)
+                return toolError(error.message);
+            throw error;
+        }),
+    };
 }
 /**
  * Builds the function that answers one parsed JSON-RPC message.
@@ -206,14 +167,18 @@ function unknownArguments(args, allowed) {
  * notification, or a response the client should not have sent.
  */
 export function createMcpHandler(options) {
-    const serverInfo = { name: SERVER_NAME, version: options.version };
-    const capabilities = { tools: {}, resources: {} };
     const readFile = options.readFile ?? ((file) => readText(nodeIo, file));
     /** The settings a request is answered under, read when the request arrives. */
     const current = async () => options.settings ? options.settings() : { patterns: options.patterns, run: options.run };
+    // Every request reads the specs, and parsing them was most of what a query
+    // cost; a document whose bytes have not changed since the last request is
+    // not parsed again (ADR-0012's amendment of 2026-09-27). The memo holds the
+    // documents of the spec set read last and nothing else: specs.ts says how.
+    const documents = options.documents ?? createDocumentMemo();
     const ruleSetOptions = ({ patterns, run }) => ({
         patterns,
         root: options.root,
+        documents,
         // No defaults of their own: loadRuleSet has them, and a second copy here
         // could never disagree with it in a way anything could see.
         includeSpecs: run?.includeSpecs,
@@ -255,6 +220,7 @@ export function createMcpHandler(options) {
             ...settings.run,
             patterns: settings.patterns,
             root: options.root,
+            documents,
             select: (assertion) => {
                 inForce += 1;
                 return paths === undefined || paths.some((query) => governs(assertion, query));
@@ -292,6 +258,13 @@ export function createMcpHandler(options) {
             })),
             inactiveSpecs: report.inactiveSpecs,
             warnings: report.warnings,
+            // A document read differently from how it was written: see ADR-0010 and ADR-0002.
+            // A run always reports them; the type leaves them out only for a result a caller built.
+            specWarnings: report.specWarnings.map((warning) => ({
+                file: warning.location.relativeFile,
+                line: warning.location.line,
+                message: warning.message,
+            })),
             exclude: report.exclude,
             config: settings.config,
             durationMs: Math.round(report.durationMs * 1000) / 1000,
@@ -299,36 +272,62 @@ export function createMcpHandler(options) {
         const text = `Checked ${scope}.\n\n${formatReport({ ...report, config: settings.config }, { color: false, verbose: false, ascii: true }, settings.run?.maxSnippets)}`;
         return { text, structured };
     }
-    async function callTool(params) {
-        const name = params['name'];
-        if (typeof name !== 'string')
-            throw new ProtocolError(INVALID_PARAMS, 'tools/call needs the name of a tool.');
-        const tool = name === 'get_architectural_rules' ? getRules : name === 'check_architecture' ? checkArchitecture : undefined;
-        if (tool === undefined)
-            throw new ProtocolError(INVALID_PARAMS, `Unknown tool: ${name}`);
-        const args = params['arguments'] ?? {};
-        if (!isObject(args))
-            throw new ProtocolError(INVALID_PARAMS, 'Tool arguments must be an object.');
-        let outcome;
-        try {
-            outcome = await tool(args);
+    /**
+     * `spec-guard impact`, answered as `impact --json` answers: the same
+     * document, and the human report as the text. Unlike the other two tools it
+     * answers without specs, as the command does, since who imports a file does
+     * not depend on them; the report says no rules are shown.
+     */
+    async function getDependents(args) {
+        const unknown = unknownArguments(args, ['paths', 'depth', 'include_inactive']);
+        if (unknown)
+            return unknown;
+        const paths = args['paths'];
+        if (!Array.isArray(paths) || paths.length === 0 || !paths.every((entry) => typeof entry === 'string')) {
+            return toolError('"paths" is required and must be a non-empty array of strings.');
         }
-        catch (error) {
-            // A path outside the root is the model's to fix; anything else is still
-            // better reported to the model than turned into a protocol failure it
-            // cannot read.
-            outcome = toolError(error instanceof QueryPathError ? error.message : `spec-guard failed: ${error instanceof Error ? error.message : String(error)}`);
+        const depth = args['depth'];
+        if (depth !== undefined && !(Number.isInteger(depth) && depth >= 1)) {
+            return toolError('"depth" must be a whole number of 1 or more: a depth of 0 would follow no import.');
         }
-        return {
-            content: [{ type: 'text', text: outcome.text }],
-            ...(outcome.structured === undefined ? {} : { structuredContent: outcome.structured }),
-            ...(outcome.isError ? { isError: true } : {}),
+        const settings = await current();
+        const includeInactive = args['include_inactive'] ?? settings.run?.ignoreStatus ?? false;
+        if (typeof includeInactive !== 'boolean')
+            return toolError('"include_inactive" must be true or false.');
+        const report = {
+            ...(await impactOf({
+                ...ruleSetOptions(settings),
+                paths: paths,
+                // Absent and undefined are one answer to impactOf: every dependent.
+                depth: depth,
+                includeInactive,
+            })),
+            config: settings.config,
         };
+        return { text: formatImpact(report), structured: { ...impactDocument(report) } };
     }
-    async function listResources() {
-        const ruleSet = await loadRuleSet(ruleSetOptions(await current()));
+    function rulesResource(ruleSet) {
         return {
-            resources: [
+            root: toPosix(options.root),
+            specFiles: ruleSet.specFiles,
+            rules: ruleSet.rules
+                .filter(({ document }) => document.inForce)
+                .map(({ assertion, document }) => viewRule(assertion, document)),
+            notInForce: ruleSet.documents
+                .filter((document) => !document.inForce)
+                .map((document) => ({ ...viewDocument(document), rules: document.directives.length })),
+            errors: ruleSet.errors.map((error) => ({
+                file: error.location.relativeFile,
+                line: error.location.line,
+                message: error.message,
+            })),
+        };
+    }
+    const resources = {
+        templates: RESOURCE_TEMPLATES,
+        async list() {
+            const ruleSet = await loadRuleSet(ruleSetOptions(await current()));
+            return [
                 {
                     uri: RULES_URI,
                     name: 'rules',
@@ -346,207 +345,44 @@ export function createMcpHandler(options) {
                     title: document.title ?? document.relativeFile,
                     mimeType: 'text/markdown',
                 })),
-            ],
-        };
-    }
-    function rulesResource(ruleSet) {
-        return {
-            root: toPosix(options.root),
-            specFiles: ruleSet.specFiles,
-            rules: ruleSet.rules
-                .filter(({ document }) => document.inForce)
-                .map(({ assertion, document }) => viewRule(assertion, document)),
-            notInForce: ruleSet.documents
-                .filter((document) => !document.inForce)
-                .map((document) => ({ ...viewDocument(document), rules: document.directives.length })),
-            errors: ruleSet.errors.map((error) => ({
-                file: error.location.relativeFile,
-                line: error.location.line,
-                message: error.message,
-            })),
-        };
-    }
-    async function readResource(params, era) {
-        const uri = params['uri'];
-        if (typeof uri !== 'string')
-            throw new ProtocolError(INVALID_PARAMS, 'resources/read needs a uri.');
-        const ruleSet = await loadRuleSet(ruleSetOptions(await current()));
-        if (uri === RULES_URI) {
-            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(rulesResource(ruleSet), null, 2) }] };
-        }
-        // Membership, never a path join: the only files this reads are the ones the
-        // spec patterns matched, so no URI can reach anything else on disk.
-        const wanted = documentPath(uri);
-        const document = ruleSet.documents.find((candidate) => candidate.relativeFile === wanted);
-        const text = document === undefined ? undefined : await readFile(document.file).catch(() => undefined);
-        if (text === undefined) {
-            throw new ProtocolError(era === 'modern' ? INVALID_PARAMS : LEGACY_RESOURCE_NOT_FOUND, 'Resource not found', { uri });
-        }
-        return { contents: [{ uri, mimeType: 'text/markdown', text }] };
-    }
-    /** A list request's cursor. This server never issues one, so any is invalid. */
-    function refuseCursor(params) {
-        if (params?.['cursor'] !== undefined)
-            throw new ProtocolError(INVALID_PARAMS, 'Invalid cursor: this server does not paginate.');
-    }
-    async function dispatch(method, params, era) {
-        const given = params ?? {};
-        if (era === 'legacy') {
-            if (method === 'initialize') {
-                return {
-                    protocolVersion: negotiateLegacyVersion(given['protocolVersion']),
-                    capabilities,
-                    serverInfo,
-                    instructions: INSTRUCTIONS,
-                };
+            ];
+        },
+        async read(uri) {
+            const ruleSet = await loadRuleSet(ruleSetOptions(await current()));
+            if (uri === RULES_URI) {
+                return [{ uri, mimeType: 'application/json', text: JSON.stringify(rulesResource(ruleSet), null, 2) }];
             }
-            if (method === 'ping')
-                return {};
-        }
-        else if (method === 'server/discover') {
-            return { supportedVersions: [...MODERN_PROTOCOL_VERSIONS], capabilities, instructions: INSTRUCTIONS };
-        }
-        switch (method) {
-            case 'tools/list':
-                refuseCursor(params);
-                return { tools: TOOLS };
-            case 'tools/call':
-                return callTool(given);
-            case 'resources/list':
-                refuseCursor(params);
-                return listResources();
-            case 'resources/templates/list':
-                refuseCursor(params);
-                return { resourceTemplates: RESOURCE_TEMPLATES };
-            case 'resources/read':
-                return readResource(given, era);
-            default:
-                throw new ProtocolError(METHOD_NOT_FOUND, 'Method not found');
-        }
-    }
-    /** The 2026-07-28 shape: a result type, caching hints where required, and identity. */
-    function modernResult(method, result) {
-        // Every cacheable result is marked stale at once and private. The rules are
-        // read fresh on each request, and a client serving an ADR edited a minute ago
-        // from cache would be doing the one thing this tool exists to stop.
-        const cacheable = method !== 'tools/call';
-        return {
-            resultType: 'complete',
-            ...result,
-            ...(cacheable ? { ttlMs: 0, cacheScope: 'private' } : {}),
-            _meta: { [SERVER_INFO_KEY]: serverInfo },
-        };
-    }
-    return async (message) => {
-        if (!isObject(message)) {
-            return {
-                jsonrpc: '2.0',
-                error: {
-                    code: INVALID_REQUEST,
-                    message: Array.isArray(message) ? 'Invalid Request: batches are not supported' : 'Invalid Request',
-                },
-            };
-        }
-        const { id, method, params } = message;
-        if (message['jsonrpc'] === '2.0' && method === undefined && isRequestId(id) && ('result' in message || 'error' in message)) {
-            return null;
-        }
-        if (message['jsonrpc'] !== '2.0' || typeof method !== 'string' || (id !== undefined && !isRequestId(id))) {
-            return { jsonrpc: '2.0', ...(isRequestId(id) ? { id } : {}), error: { code: INVALID_REQUEST, message: 'Invalid Request' } };
-        }
-        if (id === undefined)
-            return null;
-        try {
-            if (params !== undefined && !isObject(params))
-                throw new ProtocolError(INVALID_PARAMS, 'params must be an object.');
-            const era = classifyRequest(method, params);
-            const result = await dispatch(method, params, era);
-            return { jsonrpc: '2.0', id, result: era === 'modern' ? modernResult(method, result) : result };
-        }
-        catch (error) {
-            const failure = error instanceof ProtocolError
-                ? { code: error.code, message: error.message, data: error.data }
-                : { code: INTERNAL_ERROR, message: `Internal error: ${error instanceof Error ? error.message : String(error)}` };
-            return { jsonrpc: '2.0', id, error: failure };
-        }
+            // Membership, never a path join: the only files this reads are the ones the
+            // spec patterns matched, so no URI can reach anything else on disk.
+            const wanted = documentPath(uri);
+            const document = ruleSet.documents.find((candidate) => candidate.relativeFile === wanted);
+            const text = document === undefined ? undefined : await readFile(document.file).catch(() => undefined);
+            return text === undefined ? null : [{ uri, mimeType: 'text/markdown', text }];
+        },
     };
+    // Every result a modern client may cache is marked stale at once and
+    // private, which is the protocol layer's default and the one this server
+    // needs: the rules are read fresh on each request, and a client serving an
+    // ADR edited a minute ago from its cache would be doing the one thing this
+    // tool exists to stop. No prompts are declared, so prompts/list is answered
+    // "Method not found", as it is for any method the server does not have.
+    return createMcpServer({
+        name: SERVER_NAME,
+        version: options.version,
+        instructions: INSTRUCTIONS,
+        tools: [tool(GET_RULES, getRules), tool(CHECK_ARCHITECTURE, checkArchitecture), tool(GET_DEPENDENTS, getDependents)],
+        resources,
+    });
 }
 /* -------------------------------------------------------------------- stdio */
-/** The key a request is tracked under: `1` and `"1"` are different ids. */
-function trackingKey(id) {
-    return `${typeof id}:${id}`;
-}
 /**
  * Serves a handler over newline-delimited JSON-RPC until the input ends.
  *
- * The whole stdio binding. Messages are split on `\n` with a trailing `\r`
- * dropped, blank lines are skipped, and every response is written as a single
- * line - `JSON.stringify` never emits a raw newline, which is what the binding
- * requires. Requests are answered concurrently and in whatever order they
- * finish. A request the client cancels gets no response at all. When the input
- * closes, requests still running are allowed to finish and then this resolves.
+ * spec-core's `serveLines`, under the name this module has always exported:
+ * one message per line, answered concurrently, a cancelled request answered
+ * with nothing, and the input's end awaited until the last request finishes.
  */
 export function serveStdio(input, write, handle) {
-    return new Promise((resolve, reject) => {
-        // Decoded here rather than with setEncoding, which cannot be told apart
-        // from not setting one: Node reads an empty encoding name as UTF-8 too.
-        const decoder = new TextDecoder();
-        let buffer = '';
-        let running = 0;
-        let ended = false;
-        const inFlight = new Set();
-        const cancelled = new Set();
-        // Resolves once the input has ended and the last request has answered. A
-        // count rather than a set of promises, so that getting it wrong either hangs
-        // or ends early - both of which a test sees.
-        const settle = () => {
-            if (ended && running === 0)
-                resolve();
-        };
-        const receive = (line) => {
-            // A CRLF line keeps its \r: JSON allows it as whitespace, and a line of
-            // nothing else is blank.
-            if (line.trim() === '')
-                return;
-            let message;
-            try {
-                message = JSON.parse(line);
-            }
-            catch {
-                write(JSON.stringify({ jsonrpc: '2.0', error: { code: PARSE_ERROR, message: 'Parse error' } }));
-                return;
-            }
-            if (isObject(message) && message['method'] === 'notifications/cancelled') {
-                const requestId = isObject(message['params']) ? message['params']['requestId'] : undefined;
-                if (isRequestId(requestId) && inFlight.has(trackingKey(requestId)))
-                    cancelled.add(trackingKey(requestId));
-                return;
-            }
-            const key = isObject(message) && typeof message['method'] === 'string' ? trackingKey(message['id']) : undefined;
-            inFlight.add(key);
-            running += 1;
-            void handle(message).then((response) => {
-                running -= 1;
-                inFlight.delete(key);
-                if (!cancelled.delete(key) && response !== null)
-                    write(JSON.stringify(response));
-                settle();
-            });
-        };
-        input.on('data', (chunk) => {
-            buffer += decoder.decode(chunk, { stream: true });
-            for (let newline = buffer.indexOf('\n'); newline !== -1; newline = buffer.indexOf('\n')) {
-                const line = buffer.slice(0, newline);
-                buffer = buffer.slice(newline + 1);
-                receive(line);
-            }
-        });
-        input.once('end', () => {
-            ended = true;
-            receive(buffer);
-            settle();
-        });
-        input.once('error', reject);
-    });
+    return serveLines(input, write, handle);
 }
 //# sourceMappingURL=mcp.js.map