@jkudish/jev-mcp 0.9.0 → 0.10.1

package/dist/index.js

@@ -15,16 +15,30 @@
 //   jev_extract  — regex candidates, Jev picks the right verbatim value
 //   jev_review   — score a proposed diff before the task is called done
 //   jev_gate     — review a patch and verify completion claims in one call
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { choice, noul, score } from "@typesafe-ai/sdk";
 import { z } from "zod";
 import { createRequire } from "node:module";
-import { classificationDecision, claimAction, contradictsRecommendation, DECIDE_ESCAPE_HATCHES, DEFAULT_COMPOSITE_FLOOR, ensureUniqueIds, existsVerdict, hasNonEmptyEvidence, isRecord, marginOf, MAX_CANDIDATES_DECIDE, MAX_CLASSES, MAX_ITEM_CHARS, MAX_ITEMS, MAX_REQUIREMENTS, MAX_CANDIDATES, MAX_CANDIDATE_CHARS, PROBABILITY_SUM_TOLERANCE, SCORE_MEAN_TOLERANCE, MAX_GATE_CLAIMS, MAX_GATE_EVIDENCE_CHARS, MAX_GATE_EVIDENCE_ITEMS, MAX_PROPOSITIONS, MAX_PROPOSITION_CHARS, MAX_NOUL_TOTAL_CHARS, MAX_CLAIM_CHARS, MAX_REVIEW_DOC_CHARS, normalizeEvidence, rankCandidates, requireCompleteContext, resolvePolicyThresholds, REVIEW_WEIGHTS, reviewAction, reviewComposite, COMPARE_RELATIONS, ASPECT_RELATIONS, MAX_COMPARE_ASPECTS, MAX_EXTRACT_CANDIDATES, MAX_EXTRACT_CANDIDATE_CHARS, MAX_EXTRACT_FIELDS, MAX_EXTRACT_TOTAL_CHARS, MAX_RERANK_CANDIDATES, MAX_RERANK_TOTAL_CHARS, REGEX_TIMEOUT_MS, rerankByScore, RELATION_TO_VERDICT, screenRecommendation, truncate, verifyAction, VERIFY_CLAIM_CRITERIA, worstAction, } from "./lib.js";
+import { classificationDecision, claimAction, contradictsRecommendation, DECIDE_ESCAPE_HATCHES, DEFAULT_COMPOSITE_FLOOR, ensureUniqueIds, existsVerdict, hasNonEmptyEvidence, isRecord, marginOf, MAX_CANDIDATES_DECIDE, MAX_CLASSES, MAX_ITEM_CHARS, MAX_ITEMS, MAX_REQUIREMENTS, MAX_CANDIDATES, MAX_CANDIDATE_CHARS, PROBABILITY_SUM_TOLERANCE, SCORE_MEAN_TOLERANCE, MAX_GATE_CLAIMS, MAX_GATE_EVIDENCE_CHARS, MAX_GATE_EVIDENCE_ITEMS, MAX_PROPOSITIONS, MAX_PROPOSITION_CHARS, MAX_NOUL_TOTAL_CHARS, MAX_CLAIM_CHARS, MAX_REVIEW_DOC_CHARS, normalizeEvidence, rankCandidates, requireCompleteContext, resolvePolicyThresholds, REVIEW_WEIGHTS, reviewAction, reviewComposite, COMPARE_RELATIONS, ASPECT_RELATIONS, MAX_COMPARE_ASPECTS, MAX_EXTRACT_FIELDS, MAX_EXTRACT_TOTAL_CHARS, MAX_RERANK_CANDIDATES, MAX_RERANK_TOTAL_CHARS, rerankByScore, runRegex, RELATION_TO_VERDICT, screenRecommendation, truncate, verifyAction, VERIFY_CLAIM_CRITERIA, worstAction, } from "./lib.js";
 const MODEL = process.env.JEV_MCP_MODEL ?? "jev-latest";
 // Resolved at runtime so the MCP handshake version always matches the package.
 const { version: packageVersion } = createRequire(import.meta.url)("../package.json");
-const server = new McpServer({ name: "jev-mcp", version: packageVersion });
+const toolRegistrations = [];
+const tools = {
+    registerTool: ((...args) => {
+        toolRegistrations.push(args);
+    }),
+};
+export function createServer() {
+    // The tool list is static (no change notifications are ever emitted), so it
+    // advertises no listChanged capability and no client has a reason to hold a
+    // subscriptions/listen stream open, which would occupy an HTTP slot idle.
+    const server = new McpServer({ name: "jev-mcp", version: packageVersion }, { capabilities: { tools: { listChanged: false } } });
+    for (const args of toolRegistrations)
+        server.registerTool(...args);
+    return server;
+}
 import { askJev as askProvider } from "./provider.js";
 async function askJev(state, questions, signal) {
     const result = await askProvider(state, questions, MODEL, signal);
@@ -70,7 +84,7 @@ const candidatesSchema = z
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_verify
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_verify", {
+tools.registerTool("jev_verify", {
     title: "Verify claims against evidence",
     description: "Check each claim against provided evidence text with TypeSafe Jev. Returns per claim: " +
         "verdict (verified | contradicted | unsupported), full probability distribution, confidence, " +
@@ -87,7 +101,7 @@ server.registerTool("jev_verify", {
             .optional()
             .describe("Verdicts at or above this confidence stand automatically; below it they are flagged 'review'. Default 0.8."),
     }),
-}, async ({ claims, evidence: rawEvidence, auto_accept }, extra) => {
+}, async ({ claims, evidence: rawEvidence, auto_accept }, ctx) => {
     const autoAccept = auto_accept ?? 0.8;
     const evidenceItems = typeof rawEvidence === "string"
         ? [{ id: "evidence", text: rawEvidence }]
@@ -96,6 +110,14 @@ server.registerTool("jev_verify", {
             : [rawEvidence];
     const { items: evidence } = ensureUniqueIds(evidenceItems, "evidence");
     const { items: claimItems } = ensureUniqueIds(claims.map((text) => ({ text })), "claim");
+    // Keep the internal no-source option distinct from caller-provided evidence
+    // ids. A real evidence item named "none" must remain selectable and must be
+    // returned as supporting_evidence rather than being mistaken for the sentinel.
+    const evidenceIds = new Set(evidence.map((item) => item.id));
+    let noEvidenceKey = "none";
+    for (let suffix = 1; evidenceIds.has(noEvidenceKey); suffix++) {
+        noEvidenceKey = `none_${suffix}`;
+    }
     const questions = {};
     for (const claim of claimItems) {
         questions[`relation_${claim.id}`] = choice(`How does the evidence relate to claim \`${claim.id}\` (${claim.text})?`, {
@@ -105,7 +127,7 @@ server.registerTool("jev_verify", {
         });
         if (evidence.length > 1) {
             const criteria = Object.fromEntries(evidence.map((e) => [e.id, null]));
-            criteria["none"] = "No single evidence item contains the content the claim depends on";
+            criteria[noEvidenceKey] = "No single evidence item contains the content the claim depends on";
             questions[`source_${claim.id}`] = choice(`Which evidence item does claim \`${claim.id}\` (${claim.text}) rest on?`, criteria);
         }
     }
@@ -114,14 +136,15 @@ server.registerTool("jev_verify", {
         claims: claimItems,
         evidence,
     };
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const results = claimItems.map((claim) => {
         const relation = answers[`relation_${claim.id}`];
         const validated = validateChoiceAnswer(relation, Object.keys(RELATION_TO_VERDICT));
         // source_* is optional auxiliary information, requested only for multiple
         // evidence items. Its absence does not invalidate the relation verdict,
-        // but a present source must name a supplied evidence id (or "none").
-        const sourceKeys = [...evidence.map((e) => e.id), "none"];
+        // but a present source must name a supplied evidence id or the internal
+        // no-evidence option.
+        const sourceKeys = [...evidence.map((e) => e.id), noEvidenceKey];
         const source = validateChoiceAnswer(answers[`source_${claim.id}`], sourceKeys);
         const valid = validated && Object.hasOwn(RELATION_TO_VERDICT, validated.choice) &&
             (relation.confidence == null || validated.confidence !== null);
@@ -149,7 +172,7 @@ server.registerTool("jev_verify", {
             probabilities: relation.probabilities ?? null,
             confidence,
             action: confidence === null ? "review" : verifyAction(confidence, autoAccept),
-            supporting_evidence: source && source.choice !== "none" ? source.choice : null,
+            supporting_evidence: source && source.choice !== noEvidenceKey ? source.choice : null,
         };
     });
     return text({
@@ -170,7 +193,7 @@ server.registerTool("jev_verify", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_screen
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_screen", {
+tools.registerTool("jev_screen", {
     title: "Screen content before it enters agent context",
     description: "Judge fetched or external text with TypeSafe Jev before an agent reads it: probability it contains " +
         "instructions aimed at an AI agent (prompt injection), whether it has substantive content, and (when a purpose " +
@@ -185,7 +208,7 @@ server.registerTool("jev_screen", {
         block_at: z.number().min(0).max(1).optional().describe("Injection probability at or above which content is blocked. Default 0.75."),
         review_at: z.number().min(0).max(1).optional().describe("Injection probability at or above which content is flagged for review. Default 0.25."),
     }),
-}, async ({ text: content, purpose, block_at, review_at }, extra) => {
+}, async ({ text: content, purpose, block_at, review_at }, ctx) => {
     const blockAt = block_at ?? 0.75;
     const reviewAt = review_at ?? 0.25;
     const questions = {
@@ -205,7 +228,7 @@ server.registerTool("jev_screen", {
         });
     }
     const state = { content, purpose: purpose ?? null };
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const injection = validateNoulAnswer(answers.injection);
     const substance = validateNoulAnswer(answers.substance);
     const relevance = purpose ? validateNoulAnswer(answers.relevance) : undefined;
@@ -237,7 +260,7 @@ server.registerTool("jev_screen", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_noul
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_noul", {
+tools.registerTool("jev_noul", {
     title: "Calibrated probability for propositions",
     description: "Return a calibrated probability for each stated proposition with TypeSafe Jev, in one batched request: " +
         "high means likely, low means unlikely, middling means genuinely uncertain. Supplied context informs the " +
@@ -260,7 +283,7 @@ server.registerTool("jev_noul", {
             .optional()
             .describe("Decisiveness threshold: probability at or above this marks the proposition likely, at or below (1 - this) unlikely, between them uncertain. Must exceed 0.5. Default 0.85."),
     }),
-}, async ({ propositions, context: rawContext, auto_accept }, extra) => {
+}, async ({ propositions, context: rawContext, auto_accept }, ctx) => {
     const autoAccept = auto_accept ?? 0.85;
     const contextItems = typeof rawContext === "string"
         ? [{ id: "context", text: rawContext }]
@@ -285,7 +308,7 @@ server.registerTool("jev_noul", {
         });
     }
     const state = { propositions: items, context: contextItems.length ? contextItems : null };
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const rows = items.map((p) => ({
         id: p.id,
         proposition: p.text,
@@ -325,7 +348,7 @@ server.registerTool("jev_noul", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_find
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_find", {
+tools.registerTool("jev_find", {
     title: "Semantic search over candidates",
     description: "Rank candidates against a plain-language query with TypeSafe Jev — no embeddings needed. " +
         "One Choice scores every candidate id by how well it answers the query, plus a Noul checks whether " +
@@ -337,7 +360,7 @@ server.registerTool("jev_find", {
         candidates: candidatesSchema,
         top_k: z.number().int().min(1).max(50).optional().describe("How many ranked candidates to return. Default 5."),
     }),
-}, async ({ query, candidates: rawCandidates, top_k }, extra) => {
+}, async ({ query, candidates: rawCandidates, top_k }, ctx) => {
     const topK = top_k ?? 5;
     const { items: candidates } = ensureUniqueIds(rawCandidates.map((c) => ({ id: c.id ?? "", text: truncate(c.text, MAX_CANDIDATE_CHARS) })), "candidate");
     const criteria = Object.fromEntries(candidates.map((c) => [c.id, null]));
@@ -349,7 +372,7 @@ server.registerTool("jev_find", {
         }),
     };
     const state = { query, candidates };
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const exists = validateNoulAnswer(answers.exists);
     const best = validateChoiceAnswer(answers.best, candidates.map((c) => c.id));
     if (exists === null || best === null) {
@@ -383,7 +406,7 @@ server.registerTool("jev_find", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_classify
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_classify", {
+tools.registerTool("jev_classify", {
     title: "Classify items against a shared label set",
     description: "Assign each item to one class from a shared catalog with TypeSafe Jev, in one batched request: " +
         "the class catalog is sent once and every item becomes an independent Choice question. " +
@@ -411,30 +434,59 @@ server.registerTool("jev_classify", {
         auto_accept: z.number().min(0).max(1).optional().describe("Minimum top probability for auto. Default 0.85."),
         minimum_margin: z.number().min(0).max(1).optional().describe("Minimum winner-to-runner-up gap for auto. Default 0.5."),
     }),
-}, async ({ items: rawItems, classes: rawClasses, purpose, context, auto_accept, minimum_margin }, extra) => {
+}, async ({ items: rawItems, classes: rawClasses, purpose, context, auto_accept, minimum_margin }, ctx) => {
     const autoAccept = auto_accept ?? 0.85;
     const minMargin = minimum_margin ?? 0.5;
     // Preserve caller IDs exactly; use opaque internal keys (i0/c0) for the
     // wire so sanitization can never rename or collide externally, and
     // reject duplicate supplied IDs rather than silently suffixing them.
-    const seenItemIds = new Set();
-    const items = rawItems.map((it, i) => {
-        const external = it.id ?? `item${i}`;
+    // Generated fallbacks (item0/class0 style) avoid every supplied or
+    // already-used ID, so an omitted id can never collide with an explicit
+    // one — the same two-phase pattern jev_rerank uses for candidate IDs.
+    const suppliedItemIds = new Set();
+    for (const it of rawItems) {
         if (it.id != null) {
-            if (seenItemIds.has(it.id))
+            if (suppliedItemIds.has(it.id))
                 throw new Error(`Duplicate item id: ${it.id}`);
-            seenItemIds.add(it.id);
+            suppliedItemIds.add(it.id);
+        }
+    }
+    const usedItemIds = new Set(suppliedItemIds);
+    const items = rawItems.map((it, i) => {
+        let external;
+        if (it.id != null) {
+            external = it.id;
+        }
+        else {
+            external = `item${i}`;
+            let suffix = 2;
+            while (usedItemIds.has(external))
+                external = `item${i}_${suffix++}`;
         }
+        usedItemIds.add(external);
         return { external, key: `i${i}`, text: truncate(it.text, MAX_ITEM_CHARS) };
     });
-    const seenClassIds = new Set();
-    const classes = rawClasses.map((c, i) => {
-        const external = c.id ?? `class${i}`;
+    const suppliedClassIds = new Set();
+    for (const c of rawClasses) {
         if (c.id != null) {
-            if (seenClassIds.has(c.id))
+            if (suppliedClassIds.has(c.id))
                 throw new Error(`Duplicate class id: ${c.id}`);
-            seenClassIds.add(c.id);
+            suppliedClassIds.add(c.id);
         }
+    }
+    const usedClassIds = new Set(suppliedClassIds);
+    const classes = rawClasses.map((c, i) => {
+        let external;
+        if (c.id != null) {
+            external = c.id;
+        }
+        else {
+            external = `class${i}`;
+            let suffix = 2;
+            while (usedClassIds.has(external))
+                external = `class${i}_${suffix++}`;
+        }
+        usedClassIds.add(external);
         return { external, key: `c${i}`, description: truncate(c.description, MAX_ITEM_CHARS) };
     });
     if (items.length * classes.length > 8_000) {
@@ -455,7 +507,7 @@ server.registerTool("jev_classify", {
     for (const item of items) {
         questions[item.key] = choice({ task: "Which class does this item belong to?", item: { id: item.key, text: item.text } }, criteria);
     }
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const keyToExternal = new Map(classes.map((c) => [c.key, c.external]));
     const results = items.map((item) => {
         const answer = validateChoiceAnswer(answers[item.key], classes.map((c) => c.key));
@@ -484,7 +536,10 @@ server.registerTool("jev_classify", {
             decision: classificationDecision(topProbability, margin, autoAccept, minMargin),
         };
     });
-    const byClass = {};
+    // Null prototype: a caller-supplied class id such as "__proto__" or
+    // "constructor" must be tallied as its own key, not swallowed by (or
+    // read from) Object.prototype.
+    const byClass = Object.create(null);
     for (const r of results) {
         if (r.classification !== null)
             byClass[r.classification] = (byClass[r.classification] ?? 0) + 1;
@@ -508,7 +563,7 @@ server.registerTool("jev_classify", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_decide
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_decide", {
+tools.registerTool("jev_decide", {
     title: "Decide between bounded alternatives",
     description: "One unresolved, bounded decision where semantic judgment over supplied evidence could change your plan: " +
         "implementation alternatives, product tradeoffs with known preferences, workflow selection. " +
@@ -537,7 +592,7 @@ server.registerTool("jev_decide", {
             .optional()
             .describe("Include ask_user / investigate / none as Choosable options so the model can decline to rank. Default true."),
     }),
-}, async ({ decision, evidence, priorities, candidates, requirements: reqs, escape_hatches }, extra) => {
+}, async ({ decision, evidence, priorities, candidates, requirements: reqs, escape_hatches }, ctx) => {
     const includeHatches = escape_hatches ?? true;
     const requirements = reqs ?? [];
     // Reject duplicate candidate IDs and collisions with active escape hatches
@@ -576,7 +631,7 @@ server.registerTool("jev_decide", {
         candidates: candidateKeys.map((c) => ({ id: c.key, description: c.description })),
         requirements,
     };
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const keyToId = new Map(candidateKeys.map((c) => [c.key, c.id]));
     const expectedRecKeys = new Set([...candidateKeys.map((c) => c.key), ...(includeHatches ? Object.keys(DECIDE_ESCAPE_HATCHES) : [])]);
     const expectedCheckKeys = new Set(["supported", "contradicted", "unknown"]);
@@ -617,7 +672,7 @@ server.registerTool("jev_decide", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_rerank
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_rerank", {
+tools.registerTool("jev_rerank", {
     title: "Score every candidate's relevance and return them sorted",
     description: "Rerank candidates against a query with TypeSafe Jev: one independent relevance probability per candidate, " +
         "all in a single request, then sorted by score. Unlike jev_find (which picks one best answer), rerank scores " +
@@ -629,7 +684,7 @@ server.registerTool("jev_rerank", {
         candidates: candidatesSchema,
         top_k: z.number().int().min(1).max(250).optional().describe("How many ranked candidates to return. Default: all."),
     }),
-}, async ({ query, candidates: rawCandidates, top_k }, extra) => {
+}, async ({ query, candidates: rawCandidates, top_k }, ctx) => {
     const topK = top_k ?? null;
     // Caller IDs are preserved verbatim; opaque wire keys (classify pattern).
     // Duplicate supplied IDs are rejected rather than silently renamed, and
@@ -672,7 +727,7 @@ server.registerTool("jev_rerank", {
             false: "The candidate is about a different subject, or only shares vocabulary with the query",
         });
     });
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     // One invalid Noul makes the whole ordering untrustworthy; never sort a
     // missing answer as a confident zero.
     const scores = candidates.map((_, i) => {
@@ -713,7 +768,7 @@ server.registerTool("jev_rerank", {
 // ─────────────────────────────────────────────────────────────────────────────
 // jev_compare
 // ─────────────────────────────────────────────────────────────────────────────
-server.registerTool("jev_compare", {
+tools.registerTool("jev_compare", {
     title: "Compare two passages for factual agreement",
     description: "Judge the relation between two passages with TypeSafe Jev: same_fact, contradicts, or different_facts, " +
         "with the full probability distribution, confidence, and an auto-versus-review decision. " +
@@ -732,7 +787,7 @@ server.registerTool("jev_compare", {
         auto_accept: z.number().min(0).max(1).optional().describe("Minimum top probability for auto. Default 0.85."),
         minimum_margin: z.number().min(0).max(1).optional().describe("Minimum winner-to-runner-up gap for auto. Default 0.5."),
     }),
-}, async ({ passage_a, passage_b, aspects: rawAspects, purpose, auto_accept, minimum_margin }, extra) => {
+}, async ({ passage_a, passage_b, aspects: rawAspects, purpose, auto_accept, minimum_margin }, ctx) => {
     const autoAccept = auto_accept ?? 0.85;
     const minMargin = minimum_margin ?? 0.5;
     const aspects = rawAspects ?? [];
@@ -748,7 +803,7 @@ server.registerTool("jev_compare", {
         questions[`aspect_${i}`] = choice(`Judging only the aspect "${aspect}" of the two passages in the state, which relation holds?`, { ...ASPECT_RELATIONS });
     });
     const state = { purpose: purpose ?? null, passage_a: a, passage_b: b, aspects };
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const expected = new Set(Object.keys(COMPARE_RELATIONS));
     // classify-grade validation via the shared validateChoiceAnswer; the
     // overall and aspect questions share the same three relation keys.
@@ -785,60 +840,9 @@ server.registerTool("jev_compare", {
         usage,
     });
 });
-// ─────────────────────────────────────────────────────────────────────────────
-// jev_extract
-// ─────────────────────────────────────────────────────────────────────────────
-import { Worker } from "node:worker_threads";
 // Caller-supplied regex runs in a throwaway worker with a hard deadline, so a
 // catastrophic backtracking pattern can never hang the MCP server itself.
-const REGEX_WORKER_SOURCE = `
-import { parentPort, workerData } from "node:worker_threads";
-const { document, pattern, flags, maxCandidates, maxCandidateChars } = workerData;
-try {
-  const re = new RegExp(pattern, flags);
-  const seen = new Set();
-  const candidates = [];
-  let truncated = false;
-  let tooLong = 0;
-  for (const match of document.matchAll(re)) {
-    const value = match[0];
-    if (value.length === 0 || seen.has(value)) continue;
-    seen.add(value);
-    if (value.length > maxCandidateChars) { tooLong += 1; continue; }
-    if (candidates.length >= maxCandidates) { truncated = true; break; }
-    candidates.push(value);
-  }
-  parentPort.postMessage({ candidates, truncated, tooLong });
-} catch (error) {
-  parentPort.postMessage({ candidates: [], truncated: false, tooLong: 0, error: String(error && error.message ? error.message : error) });
-}
-`;
-function runRegex(document, pattern, flags) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const worker = new Worker(REGEX_WORKER_SOURCE, {
-            eval: true,
-            workerData: { document, pattern, flags, maxCandidates: MAX_EXTRACT_CANDIDATES, maxCandidateChars: MAX_EXTRACT_CANDIDATE_CHARS },
-        });
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            void worker.terminate();
-            resolve(value);
-        };
-        const timer = setTimeout(() => finish({
-            candidates: [],
-            truncated: false,
-            tooLong: 0,
-            error: `regex timed out after ${REGEX_TIMEOUT_MS}ms; simplify the pattern`,
-        }), REGEX_TIMEOUT_MS);
-        worker.on("message", (message) => finish(message));
-        worker.on("error", (error) => finish({ candidates: [], truncated: false, tooLong: 0, error: error.message }));
-    });
-}
-server.registerTool("jev_extract", {
+tools.registerTool("jev_extract", {
     title: "Extract fields by regex, Jev picks the right match",
     description: "Extract structured fields from a document with TypeSafe Jev as the picker, not the generator: your regex " +
         "finds candidate substrings in code, Jev chooses which candidate is the field's true value, and the result is " +
@@ -861,7 +865,7 @@ server.registerTool("jev_extract", {
         auto_accept: z.number().min(0).max(1).optional().describe("Minimum top probability for auto. Default 0.85."),
         minimum_margin: z.number().min(0).max(1).optional().describe("Minimum winner-to-runner-up gap for auto. Default 0.5."),
     }),
-}, async ({ document, fields: rawFields, purpose, auto_accept, minimum_margin }, extra) => {
+}, async ({ document, fields: rawFields, purpose, auto_accept, minimum_margin }, ctx) => {
     const autoAccept = auto_accept ?? 0.85;
     const minMargin = minimum_margin ?? 0.5;
     const doc = truncate(document, 50000);
@@ -878,11 +882,14 @@ server.registerTool("jev_extract", {
     // value returned.
     const fields = [];
     for (let i = 0; i < rawFields.length; i++) {
+        // A cancelled request's regex work serves nobody; stop scheduling it.
+        if (ctx.mcpReq.signal.aborted)
+            break;
         const f = rawFields[i];
         // Strip every g (and non-letters) before appending exactly one, so
         // multi-letter flags like "gi" never become "gig" and throw.
         const flags = (f.flags ?? "").replace(/[^a-z]/g, "").replace(/g/g, "") + "g";
-        const result = await runRegex(doc, f.pattern, flags);
+        const result = await runRegex(doc, f.pattern, flags, ctx.mcpReq.signal);
         fields.push({
             ...f,
             key: `f${i}`,
@@ -910,7 +917,7 @@ server.registerTool("jev_extract", {
         questions[f.key] = choice(`Which candidate is the correct value of the field "${f.id}" (${f.description}) in the document in the state? Pick the exact substring the document presents as this field's value.`, criteria);
         stateFields.push({ id: f.key, description: f.description, pattern: f.pattern });
     }
-    const { answers, usage, provider, model } = stateFields.length > 0 ? await askJev({ purpose: purpose ?? null, document: doc, fields: stateFields }, questions, extra.signal) : { answers: {}, usage: null, provider: "none", model: MODEL };
+    const { answers, usage, provider, model } = stateFields.length > 0 ? await askJev({ purpose: purpose ?? null, document: doc, fields: stateFields }, questions, ctx.mcpReq.signal) : { answers: {}, usage: null, provider: "none", model: MODEL };
     const results = fields.map((f) => {
         const flags = { candidates_truncated: f.truncated, matches_skipped_too_long: f.tooLong };
         // An incomplete candidate universe (capped or overlong-skipped matches)
@@ -1189,7 +1196,7 @@ function projectReviewHalf(answers, thresholds, truncated) {
         reasonCodes.push("accepted");
     return { ...base, action, composite, reason_codes: reasonCodes, limiting_rubrics: limitingRubrics };
 }
-server.registerTool("jev_review", {
+tools.registerTool("jev_review", {
     title: "Review a proposed patch",
     description: "Score a proposed diff against the request with TypeSafe Jev before the task is called done. " +
         "Returns 0..2 rubric scores for correctness, spec match, test gap, and blast radius (the last two lower the " +
@@ -1223,7 +1230,7 @@ server.registerTool("jev_review", {
             .optional()
             .describe("Weighted composite at or above this is required for auto. Default 0.7."),
     }),
-}, async ({ request, diff, tests, auto_accept, review_at, composite_floor }, extra) => {
+}, async ({ request, diff, tests, auto_accept, review_at, composite_floor }, ctx) => {
     const { autoAccept, reviewAt } = resolvePolicyThresholds(auto_accept ?? 0.8, review_at);
     const compositeFloor = composite_floor ?? DEFAULT_COMPOSITE_FLOOR;
     const truncated = request.length > MAX_REVIEW_DOC_CHARS ||
@@ -1235,7 +1242,7 @@ server.registerTool("jev_review", {
         diff: truncate(diff, MAX_REVIEW_DOC_CHARS),
         tests: tests ? truncate(tests, MAX_REVIEW_DOC_CHARS) : null,
     };
-    const { answers, usage, provider, model } = await askJev(state, reviewQuestions(), extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, reviewQuestions(), ctx.mcpReq.signal);
     return text({
         tool: "jev_review",
         model,
@@ -1245,7 +1252,7 @@ server.registerTool("jev_review", {
         usage,
     });
 });
-server.registerTool("jev_gate", {
+tools.registerTool("jev_gate", {
     title: "Gate completion: review a patch and verify claims",
     description: "Review a proposed patch and verify completion claims against supplied evidence in one TypeSafe Jev call. " +
         "Auto only when the patch review is accepted and every claim is verified at or above auto_accept. " +
@@ -1288,7 +1295,7 @@ server.registerTool("jev_gate", {
             .optional()
             .describe("Weighted composite at or above this is required for auto. Default 0.7."),
     }),
-}, async ({ request, diff, claims, evidence: rawEvidence, tests, auto_accept, review_at, composite_floor }, extra) => {
+}, async ({ request, diff, claims, evidence: rawEvidence, tests, auto_accept, review_at, composite_floor }, ctx) => {
     const { autoAccept, reviewAt } = resolvePolicyThresholds(auto_accept ?? 0.8, review_at);
     const compositeFloor = composite_floor ?? DEFAULT_COMPOSITE_FLOOR;
     const evidence = normalizeEvidence(rawEvidence);
@@ -1334,7 +1341,7 @@ server.registerTool("jev_gate", {
             "diff and tests belong to the separate patch review. If a claim needs a diff or test log as support, it " +
             "must be supplied in evidence." + ANTI_INJECTION, VERIFY_CLAIM_CRITERIA);
     });
-    const { answers, usage, provider, model } = await askJev(state, questions, extra.signal);
+    const { answers, usage, provider, model } = await askJev(state, questions, ctx.mcpReq.signal);
     const review = projectReviewHalf(answers, { autoAccept, reviewAt, compositeFloor }, truncated);
     // classify-grade validation via the shared validateChoiceAnswer: exact
     // keys, finite [0,1] probabilities summing to one within the shared
@@ -1411,6 +1418,13 @@ server.registerTool("jev_gate", {
 // ─────────────────────────────────────────────────────────────────────────────
 // Boot
 // ─────────────────────────────────────────────────────────────────────────────
-await server.connect(new StdioServerTransport());
-console.error(`[jev-mcp] ready — model ${MODEL}`);
+if (process.argv.includes("--http") || process.env.JEV_MCP_TRANSPORT === "http") {
+    const { serveHttp } = await import("./http.js");
+    const { url } = await serveHttp(createServer);
+    console.error(`[jev-mcp] ready — model ${MODEL}, stateless HTTP at ${url}`);
+}
+else {
+    serveStdio(createServer);
+    console.error(`[jev-mcp] ready — model ${MODEL}`);
+}
 //# sourceMappingURL=index.js.map