@patentprecheck/mcp 0.1.0

package/README.md

@@ -0,0 +1,69 @@
+# @patentprecheck/mcp — Patent PreCheck CLI + MCP server
+
+Run a patentability pre-check on your code from inside your terminal or your AI
+coding agent (Cursor, Claude Code, Codex, Antigravity). It wraps the hosted
+[Patent PreCheck](https://patentprecheck.com) engine, so **no API keys are
+required** — the scoring engine and prior-art corpus stay server-side.
+
+> Informational only — not legal advice and not a substitute for a licensed patent attorney.
+
+## What it does
+
+- Scores code or an invention description across the four USPTO statutory pillars
+  (§101 eligibility, §102 novelty, §103 non-obviousness, §101 utility) plus a
+  separate §112 filing-readiness signal.
+- Reports the band (Not Ready → File Ready), the pillar holding the band back,
+  top opportunities to strengthen, and how much prior art was consulted.
+- Exposes MCP tools so an agent can score the code it just wrote, inline.
+
+## Install
+
+```sh
+# Run directly (no install)
+npx -y @patentprecheck/mcp score ./src/widget.ts
+
+# Or install globally
+npm i -g @patentprecheck/mcp
+precheck score ./src/widget.ts
+```
+
+## CLI
+
+```sh
+precheck score ./path/to/file.ts          # human-readable report
+precheck score ./file.ts --format json    # raw JSON
+cat invention.md | precheck score -        # read from stdin
+precheck score ./file.ts --min-score 60    # exit 4 if below threshold (CI gate)
+precheck pillars                           # scoring reference (no network)
+precheck review                            # Interactive Code Review signup URL
+precheck mcp                               # run as an MCP server over stdio
+```
+
+Exit codes: `0` ok · `1` usage · `2` request error · `3` §101 gate not passed ·
+`4` below `--min-score`. stdout is clean data; progress/errors go to stderr.
+
+## Use in an AI coding agent
+
+See [`config-examples/`](./config-examples/). Quickest paths:
+
+```sh
+# Claude Code
+claude mcp add patent-precheck -- npx -y @patentprecheck/mcp mcp
+```
+
+```json
+// Cursor — .cursor/mcp.json
+{ "mcpServers": { "patent-precheck": { "command": "npx", "args": ["-y", "@patentprecheck/mcp", "mcp"] } } }
+```
+
+MCP tools: `precheck_score`, `precheck_pillars`, `precheck_start_review`.
+
+## Develop from source
+
+```sh
+cd tools/precheck-mcp
+npm install
+node bin/precheck.js pillars
+echo "a novel rate limiter that ..." | node bin/precheck.js score - --format text
+node bin/precheck.js mcp   # stdio server; blocks waiting for an MCP client
+```

package/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: patent-precheck
+description: Score code for patentability with Patent PreCheck. Use when the user asks "can this be patented?", wants a patentability/novelty/§101/§102/§103 check, or wants to know if an invention or codebase is filing-ready.
+---
+
+# Patent PreCheck — AI agent usage guide
+
+`precheck` scores source code or an invention description against the four USPTO
+statutory patentability pillars and reports filing readiness. It calls the hosted
+Patent PreCheck engine over HTTP — no local keys required.
+
+## When to use
+
+- The user asks whether code/an invention "can be patented", is "novel", "non-obvious",
+  "eligible (§101)", or "ready to file (§112)".
+- The user wants a quick patentability score before talking to an attorney.
+
+## MCP tools
+
+| Tool | Purpose |
+|------|---------|
+| `precheck_score` | Score `code` (or a local `path`) for patentability. Returns score, band, per-pillar scores, the limiting pillar, top opportunities, and prior-art count. |
+| `precheck_pillars` | Reference: the five pillars (statutes + weights) and band rules. Use to explain a score. No network. |
+| `precheck_start_review` | URL to start a paid Interactive Code Review (evidence + filing package). |
+
+## How to call `precheck_score`
+
+- Pass the relevant code as `code`, or a file path as `path`. Prefer the specific
+  module/function the user is asking about over an entire repo — focused input scores better.
+- Optional `filename` improves language/context detection.
+- Default `tier` is `free`; one free score per invention. A `402`/upgrade error means
+  the free analysis was used — offer `precheck_start_review`.
+
+## Interpreting results
+
+- `band` runs Not Ready → Building → Close to Ready → File Ready.
+- Bands enforce **per-pillar floors**, not just the weighted average: a composite of 82
+  with one pillar at 55 is **not** File Ready. `band_held_back_by` names the limiting pillar.
+- `patentability_score` (the four pillars) is primary; `filing_readiness_score` (§112) is a
+  separate documentation-quality signal.
+- If `gate_passed` is false, the subject matter is not §101-eligible and no score is issued.
+
+Always explain the limiting pillar and one or two concrete `top_opportunities`, and remind
+the user this is an informational tool, not legal advice.

package/bin/precheck.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// Patent PreCheck CLI.
+//
+//   precheck score <file|->   Score a file (or stdin) for patentability
+//   precheck pillars          Print the scoring reference (pillars + bands)
+//   precheck review           Print the Interactive Code Review signup URL
+//   precheck mcp              Run as an MCP server over stdio (for AI agents)
+//
+// stdout carries data; progress/errors go to stderr; exit codes are typed so
+// the command composes in scripts and CI.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { callAnalyze, reviewSignupUrl } from '../src/api.js';
+import { renderScoreText, renderPillarsReference } from '../src/render.js';
+import { runStdio } from '../src/server.js';
+
+const EXIT_OK = 0;
+const EXIT_USAGE = 1;
+const EXIT_REQUEST = 2;
+const EXIT_GATE = 3;
+const EXIT_BELOW_MIN = 4;
+
+function version() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json'), 'utf8')).version;
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function usage() {
+  process.stderr.write(
+    `precheck \u2014 Patent PreCheck CLI + MCP server (v${version()})\n\n` +
+      'Usage:\n' +
+      '  precheck score <file|->  [--filename name.ext] [--tier free] [--format text|json] [--min-score N]\n' +
+      '  precheck pillars\n' +
+      '  precheck review\n' +
+      '  precheck mcp\n\n' +
+      'Env: PRECHECK_API_URL, PRECHECK_TIER, PRECHECK_SITE_URL, PRECHECK_AI_ASSISTANCE\n',
+  );
+}
+
+function parseScoreArgs(argv) {
+  const opts = { input: null, filename: null, tier: undefined, format: 'text', minScore: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--filename') opts.filename = argv[++i];
+    else if (a === '--tier') opts.tier = argv[++i];
+    else if (a === '--format') opts.format = argv[++i];
+    else if (a === '--min-score') opts.minScore = Number(argv[++i]);
+    else if (a === '--help' || a === '-h') opts.help = true;
+    else if (!a.startsWith('-') || a === '-') opts.input = a;
+  }
+  return opts;
+}
+
+function readStdin() {
+  return fs.readFileSync(0, 'utf8');
+}
+
+async function cmdScore(argv) {
+  const opts = parseScoreArgs(argv);
+  if (opts.help || !opts.input) {
+    usage();
+    process.exit(opts.help ? EXIT_OK : EXIT_USAGE);
+  }
+
+  let code;
+  let filename = opts.filename;
+  if (opts.input === '-') {
+    code = readStdin();
+    if (!filename) filename = 'stdin.txt';
+  } else {
+    const filePath = path.resolve(opts.input);
+    if (!fs.existsSync(filePath)) {
+      process.stderr.write(`File not found: ${filePath}\n`);
+      process.exit(EXIT_USAGE);
+    }
+    code = fs.readFileSync(filePath, 'utf8');
+    if (!filename) filename = path.basename(filePath);
+  }
+
+  process.stderr.write('Analyzing with Patent PreCheck\u2026\n');
+  const { ok, data, error } = await callAnalyze({ code, filename, tier: opts.tier });
+  if (!ok) {
+    process.stderr.write(`${error}\n`);
+    process.exit(EXIT_REQUEST);
+  }
+
+  if (opts.format === 'json') {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+  } else {
+    process.stdout.write(renderScoreText(data, { filename }) + '\n');
+  }
+
+  if (data.gate_passed === false) process.exit(EXIT_GATE);
+
+  const score = Number(data.patentability_score ?? data.overall_score);
+  if (Number.isFinite(opts.minScore) && Number.isFinite(score) && score < opts.minScore) {
+    process.stderr.write(`Patentability score ${score} is below --min-score ${opts.minScore}\n`);
+    process.exit(EXIT_BELOW_MIN);
+  }
+  process.exit(EXIT_OK);
+}
+
+async function main() {
+  const [, , cmd, ...rest] = process.argv;
+  switch (cmd) {
+    case 'score':
+      await cmdScore(rest);
+      break;
+    case 'pillars':
+      process.stdout.write(renderPillarsReference() + '\n');
+      break;
+    case 'review':
+      process.stdout.write(reviewSignupUrl() + '\n');
+      break;
+    case 'mcp':
+      await runStdio();
+      break;
+    case '--version':
+    case '-V':
+      process.stdout.write(version() + '\n');
+      break;
+    case '--help':
+    case '-h':
+    case undefined:
+      usage();
+      process.exit(cmd === undefined ? EXIT_USAGE : EXIT_OK);
+      break;
+    default:
+      process.stderr.write(`Unknown command: ${cmd}\n`);
+      usage();
+      process.exit(EXIT_USAGE);
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`Error: ${err.message}\n`);
+  process.exit(EXIT_REQUEST);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@patentprecheck/mcp",
+  "version": "0.1.0",
+  "description": "Patent PreCheck CLI + MCP server — run a patentability pre-check on your code from inside Cursor, Claude Code, Codex, and other AI coding agents.",
+  "type": "module",
+  "bin": {
+    "precheck": "bin/precheck.js"
+  },
+  "exports": {
+    ".": "./src/server.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "SKILL.md",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "start": "node bin/precheck.js mcp",
+    "smoke": "node bin/precheck.js score - --format text"
+  },
+  "keywords": [
+    "patent",
+    "patentability",
+    "mcp",
+    "cli",
+    "ai-agent",
+    "cursor",
+    "claude-code",
+    "codex",
+    "prior-art"
+  ],
+  "author": "Patent PreCheck",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  }
+}

package/src/api.js

@@ -0,0 +1,98 @@
+// Thin client for the public Patent PreCheck analyze API.
+//
+// The MCP server / CLI never talks to the database or any LLM directly — it
+// POSTs to the hosted endpoint, so an installing developer needs no API keys
+// or secrets. The scoring engine, prior-art corpus, and source registry all
+// stay server-side.
+
+const DEFAULT_API = 'https://patentprecheck.com/.netlify/functions/analyze';
+const DEFAULT_SITE = 'https://patentprecheck.com';
+
+// Mirror the env conventions already used by scripts/precheck-from-file.js so
+// the CLI and MCP server behave identically. PRECHECK_* is preferred; the
+// legacy PPC_* names are accepted as fallbacks.
+export function apiUrl() {
+  return process.env.PRECHECK_API_URL || process.env.PPC_API_URL || DEFAULT_API;
+}
+
+export function siteUrl() {
+  return process.env.PRECHECK_SITE_URL || process.env.PPC_SITE_URL || DEFAULT_SITE;
+}
+
+export function defaultTier() {
+  return process.env.PRECHECK_TIER || process.env.PPC_TIER || 'free';
+}
+
+export function defaultAiAssistance() {
+  return process.env.PRECHECK_AI_ASSISTANCE || process.env.PPC_AI_ASSISTANCE || 'yes_some';
+}
+
+export const MIN_CODE_CHARS = 10;
+
+/**
+ * Call the hosted analyze endpoint.
+ * @returns {Promise<{ok: boolean, status: number, data: any, error: string|null}>}
+ */
+export async function callAnalyze({ code, filename, tier, aiAssistance, timeoutMs = 60000 } = {}) {
+  if (typeof code !== 'string' || code.trim().length < MIN_CODE_CHARS) {
+    return {
+      ok: false,
+      status: 0,
+      data: null,
+      error: `Provide at least ${MIN_CODE_CHARS} characters of code or an invention description.`,
+    };
+  }
+
+  const body = {
+    code,
+    filename: filename || 'invention.txt',
+    tier: tier || defaultTier(),
+    ai_assistance_declared: aiAssistance || defaultAiAssistance(),
+  };
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(apiUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const msg = err && err.name === 'AbortError' ? 'analyze request timed out' : err.message;
+    return { ok: false, status: 0, data: null, error: `request failed: ${msg}` };
+  }
+  clearTimeout(timer);
+
+  const text = await res.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return {
+      ok: false,
+      status: res.status,
+      data: null,
+      error: `non-JSON response (${res.status}): ${text.slice(0, 300)}`,
+    };
+  }
+
+  if (!res.ok) {
+    return {
+      ok: false,
+      status: res.status,
+      data,
+      error: data.error || `analyze failed (HTTP ${res.status})`,
+    };
+  }
+
+  return { ok: true, status: res.status, data, error: null };
+}
+
+/** URL that starts a paid Interactive Code Review for a given invention. */
+export function reviewSignupUrl() {
+  return `${siteUrl()}/review-signup`;
+}

package/src/render.js

@@ -0,0 +1,112 @@
+// Human-readable rendering of analyze results, shared by the CLI and the MCP
+// server so an agent and a terminal user see the same summary.
+
+import { reviewSignupUrl } from './api.js';
+
+export const PILLARS = [
+  { key: 'eligibility', label: 'Eligibility', statute: '§101 (Alice/Mayo)', weight: '25%', question: 'Is it more than an abstract idea?' },
+  { key: 'novelty', label: 'Novelty', statute: '§102', weight: '25%', question: 'Is it new?' },
+  { key: 'non_obvious', label: 'Non-obviousness', statute: '§103', weight: '30%', question: 'Is it inventive?' },
+  { key: 'utility', label: 'Utility', statute: '§101 (utility)', weight: '10%', question: 'Does it work and does it matter?' },
+  { key: 'filing_readiness', label: 'Filing readiness', statute: '§112', weight: '10%', question: 'Is your documentation strong enough to file?' },
+];
+
+export const BANDS = [
+  { band: 'file_ready', label: 'File Ready', score: '\u2265 80', floor: 'every pillar \u2265 70' },
+  { band: 'close_to_ready', label: 'Close to Ready', score: '\u2265 60', floor: 'every pillar \u2265 50' },
+  { band: 'building', label: 'Building', score: '\u2265 40', floor: '\u2014' },
+  { band: 'not_ready', label: 'Not Ready', score: '0\u201339', floor: '\u2014' },
+];
+
+function humanizePillar(key) {
+  const found = PILLARS.find((p) => p.key === key);
+  return found ? `${found.label} (${found.statute})` : key || '\u2014';
+}
+
+/** Render the pillars/bands reference (no network). */
+export function renderPillarsReference() {
+  const lines = [];
+  lines.push('Patent PreCheck scores four statutory patentability pillars (weighted) plus a');
+  lines.push('separate Filing Readiness (\u00a7112) signal, behind a \u00a7101 subject-matter gate.');
+  lines.push('');
+  lines.push('Pillars:');
+  for (const p of PILLARS) {
+    lines.push(`  ${p.label.padEnd(18)} ${p.statute.padEnd(18)} ${p.weight.padEnd(5)} ${p.question}`);
+  }
+  lines.push('');
+  lines.push('Bands (enforced floors, not just a weighted average):');
+  for (const b of BANDS) {
+    lines.push(`  ${b.label.padEnd(16)} score ${b.score.padEnd(6)}  floor: ${b.floor}`);
+  }
+  lines.push('');
+  lines.push('A composite of 82 with one pillar at 55 does NOT reach File Ready; band_held_back_by');
+  lines.push('names the limiting pillar so you know exactly what to strengthen.');
+  return lines.join('\n');
+}
+
+/** Render an analyze result as a compact, terminal-friendly report. */
+export function renderScoreText(data, { filename } = {}) {
+  if (!data || typeof data !== 'object') return 'No result.';
+
+  const lines = [];
+  const title = filename ? `Patent PreCheck \u2014 ${filename}` : 'Patent PreCheck';
+  lines.push(title);
+  lines.push('='.repeat(title.length));
+
+  if (data.gate_passed === false) {
+    lines.push('');
+    lines.push('Gate: NOT eligible patentable subject matter (\u00a7101).');
+    if (data.gate_reason) lines.push(`Reason: ${data.gate_reason}`);
+    lines.push('No patentability score is issued for non-eligible subject matter.');
+    return lines.join('\n');
+  }
+
+  const score = data.patentability_score ?? data.overall_score;
+  const bandLabel = data.patentability_band_label || data.band_label || data.band || '\u2014';
+  const heldBack = data.patentability_held_back_by || data.band_held_back_by;
+
+  lines.push('');
+  lines.push(`Band:  ${bandLabel}  (patentability ${score ?? '\u2014'}/100)`);
+  if (data.filing_readiness_score != null) {
+    lines.push(`Filing readiness (\u00a7112): ${data.filing_readiness_score}/100  ${data.filing_readiness_band_label || ''}`.trimEnd());
+  }
+  if (heldBack) lines.push(`Held back by: ${humanizePillar(heldBack)}`);
+  if (data.technology_domain) lines.push(`Domain: ${data.technology_domain}`);
+
+  const ps = data.pillar_scores || {};
+  if (Object.keys(ps).length) {
+    lines.push('');
+    lines.push('Pillars:');
+    for (const p of PILLARS) {
+      if (ps[p.key] == null) continue;
+      const tag = p.key === 'filing_readiness' ? '  (secondary)' : '';
+      lines.push(`  ${(`${p.label} (${p.statute})`).padEnd(34)} ${String(ps[p.key]).padStart(3)}${tag}`);
+    }
+  }
+
+  const opps = Array.isArray(data.top_opportunities) ? data.top_opportunities : [];
+  if (opps.length) {
+    lines.push('');
+    lines.push('Top opportunities to strengthen:');
+    opps.slice(0, 5).forEach((o, i) => {
+      const area = o.area || humanizePillar(o.pillar);
+      lines.push(`  ${i + 1}. ${area}${o.action ? ` \u2014 ${o.action}` : ''}`);
+    });
+  }
+
+  if (data.prior_art_match_count != null) {
+    lines.push('');
+    lines.push(`Prior art consulted: ${data.prior_art_match_count}`);
+    const teaser = Array.isArray(data.prior_art_teaser) ? data.prior_art_teaser : [];
+    teaser.slice(0, 5).forEach((t) => {
+      const label = typeof t === 'string' ? t : t.title || t.publication_number || '';
+      if (label) lines.push(`  \u2022 ${label}`);
+    });
+  }
+
+  lines.push('');
+  lines.push(`Next step \u2014 strengthen this with a live, evidence-backed Interactive Code Review:`);
+  lines.push(`  ${reviewSignupUrl()}`);
+
+  return lines.join('\n');
+}

package/src/server.js

@@ -0,0 +1,143 @@
+// Patent PreCheck MCP server.
+//
+// Exposes the hosted patentability engine as MCP tools so a developer inside
+// Cursor / Claude Code / Codex can score the code they just wrote without
+// leaving their agent. Transport is stdio; launch via `precheck mcp`.
+
+import fs from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+import { callAnalyze, reviewSignupUrl, MIN_CODE_CHARS } from './api.js';
+import { renderScoreText, renderPillarsReference } from './render.js';
+
+function readPkgVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json'), 'utf8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function textResult(text, { isError = false } = {}) {
+  return { content: [{ type: 'text', text }], ...(isError ? { isError: true } : {}) };
+}
+
+/** Build and return the configured MCP server. */
+export function buildServer(version = readPkgVersion()) {
+  const server = new McpServer({ name: 'patent-precheck', version });
+
+  server.registerTool(
+    'precheck_score',
+    {
+      title: 'Patent PreCheck — score patentability',
+      description:
+        'Run a patentability pre-check on source code or an invention description. ' +
+        'Returns a 0\u2013100 patentability score across the four USPTO statutory pillars ' +
+        '(\u00a7101 eligibility, \u00a7102 novelty, \u00a7103 non-obviousness, \u00a7101 utility), a ' +
+        'separate \u00a7112 filing-readiness signal, the band (Not Ready \u2192 File Ready), the ' +
+        'pillar that holds the band back, top opportunities to strengthen, and a count of ' +
+        'prior-art matches consulted. Provide either `code` (the text) or `path` (a local file to read).',
+      inputSchema: {
+        code: z
+          .string()
+          .optional()
+          .describe('The source code or invention description to analyze (>= 10 chars).'),
+        path: z
+          .string()
+          .optional()
+          .describe('Path to a local file to read and analyze instead of passing `code` inline.'),
+        filename: z
+          .string()
+          .optional()
+          .describe('Optional filename hint (e.g. main.ts) used for language/context.'),
+        tier: z
+          .enum(['free', 'paid_review', 'enterprise'])
+          .optional()
+          .describe('Analysis tier. Defaults to free; paid tiers require server-side entitlement.'),
+      },
+    },
+    async ({ code, path: filePath, filename, tier }) => {
+      let text = typeof code === 'string' ? code : '';
+      let name = filename;
+      if (!text && filePath) {
+        try {
+          text = await readFile(filePath, 'utf8');
+        } catch (err) {
+          return textResult(`Could not read file "${filePath}": ${err.message}`, { isError: true });
+        }
+        if (!name) name = path.basename(filePath);
+      }
+      if (!text || text.trim().length < MIN_CODE_CHARS) {
+        return textResult(
+          `Provide at least ${MIN_CODE_CHARS} characters via "code" or a readable "path".`,
+          { isError: true },
+        );
+      }
+
+      const { ok, data, error } = await callAnalyze({ code: text, filename: name, tier });
+      if (!ok) {
+        const hint =
+          error && /HTTP 402|Upgrade/i.test(error)
+            ? ' (this invention has used its free analysis; start an Interactive Code Review at ' +
+              reviewSignupUrl() +
+              ')'
+            : '';
+        return textResult(`Patent PreCheck error: ${error}${hint}`, { isError: true });
+      }
+
+      const summary = renderScoreText(data, { filename: name });
+      const compact = JSON.stringify(data);
+      return {
+        content: [
+          { type: 'text', text: summary },
+          { type: 'text', text: `Raw result JSON:\n\`\`\`json\n${compact}\n\`\`\`` },
+        ],
+      };
+    },
+  );
+
+  server.registerTool(
+    'precheck_pillars',
+    {
+      title: 'Patent PreCheck — scoring reference',
+      description:
+        'List the five patentability pillars (with statutes and weights) and the band rules ' +
+        'used by precheck_score. Use this to explain a score to the user. No network call.',
+      inputSchema: {},
+    },
+    async () => textResult(renderPillarsReference()),
+  );
+
+  server.registerTool(
+    'precheck_start_review',
+    {
+      title: 'Patent PreCheck — start an Interactive Code Review',
+      description:
+        'Return the URL where the user can start a paid, live Interactive Code Review that ' +
+        'strengthens each pillar with evidence and produces a filing package. Use after a ' +
+        'precheck_score when the user wants to act on the result.',
+      inputSchema: {},
+    },
+    async () =>
+      textResult(
+        `Start an Interactive Code Review (live coaching + evidence + filing package):\n${reviewSignupUrl()}`,
+      ),
+  );
+
+  return server;
+}
+
+/** Connect the server over stdio and block until the client disconnects. */
+export async function runStdio() {
+  const server = buildServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}