@warmdrift/kgauto-check 0.3.0 → 0.4.1

package/dist/chunk-NHTVNYK2.js

@@ -1,477 +0,0 @@
-// src/extract.ts
-import { z } from "zod";
-var CallSiteSchema = z.object({
-  /** Agent-chosen stable label, e.g. "api/summarize.ts:42" or "hunt loop". */
-  id: z.string().min(1),
-  /** Model id exactly as configured in the project. */
-  model: z.string().min(1),
-  /** How the model id is selected at this site. */
-  modelSelection: z.enum(["hardcoded", "config", "env", "dynamic"]).optional(),
-  /**
-   * Best-guess intent archetype from kgauto's dialect (ask, classify,
-   * critique, extract, generate, hunt, plan, summarize, transform).
-   * Free-form here; validated softly against the roster's dialect.
-   */
-  archetype: z.string().optional(),
-  /** Typical input size in tokens (estimate is fine; ~4 chars/token). */
-  estInputTokens: z.number().nonnegative().optional(),
-  /** Worst-case input size in tokens, if larger than typical. */
-  maxInputTokens: z.number().nonnegative().optional(),
-  /** Typical output size in tokens. */
-  estOutputTokens: z.number().nonnegative().optional(),
-  /** Number of tool definitions sent with the call. */
-  toolCount: z.number().int().nonnegative().optional(),
-  /** Does the site rely on the model making parallel tool calls? */
-  usesParallelToolCalls: z.boolean().optional(),
-  /** Does the site parse the response as JSON / expect schema output? */
-  expectsStructuredOutput: z.boolean().optional(),
-  streaming: z.boolean().optional(),
-  /** What happens when the call fails. */
-  retry: z.enum(["none", "same-model", "fallback-chain", "unknown"]).optional(),
-  /** Fallback model ids, when retry is 'fallback-chain'. */
-  fallbackModels: z.array(z.string()).optional(),
-  /** Rough call volume, if inferable (cron cadence, traffic, logs). */
-  estCallsPerMonth: z.number().positive().optional(),
-  /** Anything structural the agent thinks matters. Never prompt text. */
-  notes: z.string().max(500).optional()
-});
-var ExtractSchema = z.object({
-  project: z.object({
-    name: z.string().min(1),
-    description: z.string().max(500).optional()
-  }),
-  callSites: z.array(CallSiteSchema).min(1),
-  notes: z.string().max(1e3).optional()
-});
-
-// src/version.ts
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-var CHECK_VERSION = (() => {
-  try {
-    const here = dirname(fileURLToPath(import.meta.url));
-    return JSON.parse(readFileSync(join(here, "../package.json"), "utf8")).version;
-  } catch {
-    return "0.0.0-unknown";
-  }
-})();
-
-// src/engine.ts
-import {
-  allProfiles,
-  tryGetProfile,
-  resolveModelAlias,
-  isArchetype,
-  LIBRARY_VERSION
-} from "@warmdrift/kgauto-compiler";
-var DESTINATION_SENTENCE = "This check ran locally against kgauto\u2019s bundled model catalog. Nothing was uploaded; no rows were written anywhere.";
-var defaultResolve = (id) => {
-  const canonical = resolveModelAlias(id);
-  return { canonical, profile: tryGetProfile(id) };
-};
-function perCallCostUsd(p, inTok, outTok) {
-  return inTok / 1e6 * p.costInputPer1m + outTok / 1e6 * p.costOutputPer1m;
-}
-function runCheck(extract, opts = {}) {
-  const resolve = opts.resolve ?? defaultResolve;
-  const roster = opts.roster ?? allProfiles;
-  const findings = [];
-  let n = 0;
-  const add = (f) => {
-    findings.push({ id: `F${++n}`, ...f });
-  };
-  const unknownModels = /* @__PURE__ */ new Set();
-  for (const site of extract.callSites) {
-    const { canonical, profile } = resolve(site.model);
-    const at = [site.id];
-    if (canonical !== site.model) {
-      add({
-        severity: "yellow",
-        confidence: "certain",
-        title: `\`${site.model}\` is a provider compat alias for \`${canonical}\``,
-        detail: `The provider silently serves a different model than the id you configured. Aliases hide capability and price drift \u2014 the served model's context window and prices can differ by 10\u201350\xD7 from what the alias name suggests, with no error.`,
-        basis: "kgauto alias table (verified against provider docs)",
-        callSites: at
-      });
-    }
-    if (!profile) {
-      unknownModels.add(site.model);
-      add({
-        severity: "info",
-        confidence: "certain",
-        title: `\`${site.model}\` is not in kgauto's verified catalog`,
-        detail: `kgauto has no measured evidence for this model and will not fabricate a verdict on it. Checks below skip this site. (If it's a new release, the catalog gains models through doc-verified onboarding, never from training-data guesses.)`,
-        basis: "catalog lookup",
-        callSites: at
-      });
-      continue;
-    }
-    if (profile.status === "legacy") {
-      add({
-        severity: "yellow",
-        confidence: "certain",
-        title: `\`${canonical}\` is a legacy model`,
-        detail: `The provider lists it as superseded. Legacy models are the deprecation-risk tier: they can start 404ing for whole account cohorts with no code change on your side. A current-generation successor exists in the same family.`,
-        basis: `catalog status: legacy${profile.verifiedAgainstDocs ? ` (verified ${profile.verifiedAgainstDocs})` : ""}`,
-        callSites: at
-      });
-    } else if (profile.status === "preview") {
-      add({
-        severity: "info",
-        confidence: "certain",
-        title: `\`${canonical}\` is a preview model`,
-        detail: `Preview pricing and limits are not yet doc-verified; both can change at GA.`,
-        basis: "catalog status: preview",
-        callSites: at
-      });
-    }
-    const worstIn = site.maxInputTokens ?? site.estInputTokens;
-    if (worstIn !== void 0 && worstIn > profile.maxContextTokens) {
-      add({
-        severity: "red",
-        confidence: site.maxInputTokens !== void 0 ? "certain" : "likely",
-        title: `input can exceed \`${canonical}\`'s context window`,
-        detail: `Your ${site.maxInputTokens !== void 0 ? "worst-case" : "typical"} input estimate (${worstIn.toLocaleString()} tokens) exceeds the model's ${profile.maxContextTokens.toLocaleString()}-token window. Those calls fail outright or silently truncate, depending on the provider.`,
-        basis: `your estimate vs catalog maxContextTokens=${profile.maxContextTokens}`,
-        callSites: at
-      });
-    }
-    if (site.estOutputTokens !== void 0 && site.estOutputTokens > profile.maxOutputTokens) {
-      add({
-        severity: "red",
-        confidence: "likely",
-        title: `expected output exceeds \`${canonical}\`'s output cap`,
-        detail: `You expect ~${site.estOutputTokens.toLocaleString()} output tokens; the model caps at ${profile.maxOutputTokens.toLocaleString()}. Responses will be cut mid-generation \u2014 on JSON output this is the classic unparseable-tail failure.`,
-        basis: `your estimate vs catalog maxOutputTokens=${profile.maxOutputTokens}`,
-        callSites: at
-      });
-    }
-    if (site.toolCount !== void 0 && site.toolCount > profile.maxTools) {
-      add({
-        severity: "red",
-        confidence: "certain",
-        title: `${site.toolCount} tools exceeds \`${canonical}\`'s ceiling of ${profile.maxTools}`,
-        detail: `Calls with more tool definitions than the model supports are rejected or degrade hard.`,
-        basis: `extract toolCount vs catalog maxTools=${profile.maxTools}`,
-        callSites: at
-      });
-    }
-    if (site.usesParallelToolCalls && !profile.parallelToolCalls) {
-      add({
-        severity: "red",
-        confidence: "certain",
-        title: `\`${canonical}\` does not make parallel tool calls`,
-        detail: `This site relies on parallel tool use, but the model calls tools sequentially \u2014 measured at roughly 10\xD7 fewer operations per step on agentic workloads. The work still "succeeds", just slowly and shallowly, which is why this rarely shows up as an error.`,
-        basis: "catalog parallelToolCalls=false (measured, not vendor-claimed)",
-        callSites: at
-      });
-    }
-    if (site.expectsStructuredOutput && profile.structuredOutput === "none") {
-      add({
-        severity: "red",
-        confidence: "certain",
-        title: `\`${canonical}\` has no structured-output support, but this site parses JSON`,
-        detail: `Output-shape failures here land on your parser as intermittent exceptions. Models with native or grammar-constrained output move that failure from runtime to the request.`,
-        basis: "catalog structuredOutput=none",
-        callSites: at
-      });
-    }
-    const archetype = site.archetype && isArchetype(site.archetype) ? site.archetype : void 0;
-    for (const cliff of profile.cliffs) {
-      if (cliff.whenIntent && cliff.whenIntent !== archetype) continue;
-      const metricValue = cliff.metric === "input_tokens" ? worstIn : cliff.metric === "tool_count" ? site.toolCount : void 0;
-      if (metricValue === void 0 || metricValue < cliff.threshold) continue;
-      add({
-        severity: "yellow",
-        confidence: "likely",
-        title: `\`${canonical}\` has a known ${cliff.metric.replaceAll("_", " ")} cliff at ${cliff.threshold.toLocaleString()} \u2014 this site crosses it`,
-        detail: `Above this threshold${cliff.whenIntent ? ` on ${cliff.whenIntent} work` : ""}, quality degrades in a measured, repeatable way (compiler action when routed through kgauto: ${cliff.action.replaceAll("_", " ")}). Your estimate of ${metricValue.toLocaleString()} sits over the line.`,
-        basis: `catalog cliff rule vs your estimate; the same rule the kgauto compiler executes`,
-        callSites: at
-      });
-    }
-    if (site.retry === "none") {
-      add({
-        severity: "yellow",
-        confidence: "certain",
-        title: `no fallback path \u2014 a single ${profile.provider} incident takes this surface to raw errors`,
-        detail: `Provider outages are routine and undramatic: billing exhaustion, quota, silent deprecations. With no cross-provider fallback, every one of them reaches your users directly.`,
-        basis: "extract retry=none",
-        callSites: at
-      });
-    }
-    if (site.estInputTokens !== void 0 && site.estOutputTokens !== void 0 && site.estInputTokens + site.estOutputTokens > 0) {
-      const perCall = perCallCostUsd(profile, site.estInputTokens, site.estOutputTokens);
-      const monthly = site.estCallsPerMonth !== void 0 ? perCall * site.estCallsPerMonth : void 0;
-      const inputShare = site.estInputTokens / (site.estInputTokens + site.estOutputTokens);
-      add({
-        severity: "info",
-        confidence: "likely",
-        title: `~$${perCall.toFixed(4)}/call on \`${canonical}\`${monthly !== void 0 ? ` (~$${monthly.toFixed(2)}/month at your volume)` : ""}`,
-        detail: `From your token estimates and doc-verified prices ($${profile.costInputPer1m}/M in, $${profile.costOutputPer1m}/M out${profile.verifiedAgainstDocs ? `, verified ${profile.verifiedAgainstDocs}` : ""}).`,
-        basis: "arithmetic on your estimates \xD7 verified catalog prices",
-        callSites: at
-      });
-      if (inputShare > 0.85) {
-        add({
-          severity: "yellow",
-          confidence: "likely",
-          title: `${Math.round(inputShare * 100)}% of this site's tokens are input`,
-          detail: `Above ~85% input share, spend is dominated by context rather than answers \u2014 the single strongest signal of a leaking prompt. What's actually IN that context, and how much of it each call needed, is measurable, not guessable.`,
-          basis: "your token estimates; the >85% threshold is a measured portfolio heuristic",
-          callSites: at
-        });
-      }
-      if (archetype) {
-        const cheaper = roster().filter(
-          (p) => p.status === "current" && p.id !== canonical && perCallCostUsd(p, site.estInputTokens, site.estOutputTokens) < perCall * 0.5
-        ).sort(
-          (a, b) => perCallCostUsd(a, site.estInputTokens, site.estOutputTokens) - perCallCostUsd(b, site.estInputTokens, site.estOutputTokens)
-        );
-        const cheapest = cheaper[0];
-        if (cheapest) {
-          add({
-            severity: "info",
-            confidence: "measurable-only",
-            title: `${cheaper.length} current model(s) price under half of \`${canonical}\` on ${archetype} work`,
-            detail: `Cheapest: \`${cheapest.id}\` at ~$${perCallCostUsd(cheapest, site.estInputTokens, site.estOutputTokens).toFixed(4)}/call. The price is arithmetic; whether any of them holds YOUR quality bar on ${archetype} work is exactly what a one-day observe run plus kgauto's judged eval measures. kgauto never promotes a model on price alone.`,
-            basis: "verified catalog prices; quality deliberately unclaimed",
-            callSites: at
-          });
-        }
-      }
-    }
-  }
-  add({
-    severity: "info",
-    confidence: "measurable-only",
-    title: "what a code read cannot tell you (and a one-day observe run can)",
-    detail: `Your actual failure rate per model (walkaway failures look like green health checks); your actual input-waste ratio per call; which call sites dominate spend; whether a cheaper model holds quality on your real traffic. These need one day of observed calls \u2014 observe-only, your keys, no routing changes.`,
-    basis: "the honest limit of static analysis",
-    callSites: extract.callSites.map((s) => s.id)
-  });
-  const merged = [];
-  const byKey = /* @__PURE__ */ new Map();
-  for (const f of findings) {
-    const key = `${f.severity}|${f.confidence}|${f.title}`;
-    const existing = byKey.get(key);
-    if (existing) {
-      for (const cs of f.callSites) {
-        if (!existing.callSites.includes(cs)) existing.callSites.push(cs);
-      }
-    } else {
-      const copy = { ...f, callSites: [...f.callSites] };
-      byKey.set(key, copy);
-      merged.push(copy);
-    }
-  }
-  return {
-    findings: merged,
-    card: renderCard(extract, merged, unknownModels),
-    catalogVersion: LIBRARY_VERSION
-  };
-}
-var TIER_ORDER = ["certain", "likely", "measurable-only"];
-var TIER_HEADING = {
-  certain: "Certain \u2014 read from your code and kgauto\u2019s verified catalog",
-  likely: "Likely \u2014 priced from your estimates",
-  "measurable-only": "Only measurable \u2014 what the observe day answers"
-};
-var SEV_MARK = { red: "\u{1F534}", yellow: "\u{1F7E1}", info: "\u2139\uFE0F" };
-function renderCard(extract, findings, unknownModels = /* @__PURE__ */ new Set()) {
-  const lines = [];
-  lines.push(`# kgauto check \u2014 ${extract.project.name}`);
-  lines.push("");
-  const models = [...new Set(extract.callSites.map((s) => s.model))];
-  lines.push(
-    `${extract.callSites.length} AI call site(s), ${models.length} model(s): ${models.map((m) => `\`${m}\``).join(", ")}` + (unknownModels.size > 0 ? ` (${unknownModels.size} unknown to the catalog)` : "")
-  );
-  for (const tier of TIER_ORDER) {
-    const group = findings.filter((f) => f.confidence === tier);
-    if (group.length === 0) continue;
-    lines.push("");
-    lines.push(`## ${TIER_HEADING[tier]}`);
-    lines.push("");
-    for (const f of group) {
-      lines.push(`- ${SEV_MARK[f.severity]} **${f.title}** \u2014 ${f.detail}`);
-      lines.push(`  <sub>${f.callSites.join(", ")} \xB7 basis: ${f.basis}</sub>`);
-    }
-  }
-  lines.push("");
-  lines.push("---");
-  lines.push(`*${DESTINATION_SENTENCE}*`);
-  lines.push(`<sub>kgauto-check ${CHECK_VERSION} \xB7 catalog ${LIBRARY_VERSION}</sub>`);
-  return lines.join("\n");
-}
-
-// src/instructions.ts
-var SERVER_INSTRUCTIONS = `You are talking to kgauto-check, a local, offline checker for AI call surfaces.
-
-Flow: (1) call start_check to get extraction instructions, (2) read THIS project's code yourself and build the extract, (3) call run_check with it, (4) present the returned card to your human verbatim (it is grouped by confidence tier on purpose), (5) if they want measured numbers, call get_observe_day_plan.
-
-Privacy contract, which you should relay to your human: the extract contains identifiers and counts only \u2014 never prompt text, never source code, never secrets. ${DESTINATION_SENTENCE}
-
-get_model_facts answers one-off questions about any model id from the same verified catalog \u2014 it is what makes keeping this server installed useful between checks.`;
-var START_CHECK_INSTRUCTIONS = `# kgauto check \u2014 extraction instructions (for you, the agent)
-
-Your job: read this project's code and build an extract of its AI call surface. You have repo access; kgauto does not, by design.
-
-## What to find
-Scan for LLM API usage: provider SDK imports (anthropic, openai, @google/generative-ai / @google/genai, ai-sdk, litellm, langchain, ...), raw HTTPS calls to provider endpoints, and any internal wrapper around them. Each distinct place the project sends a prompt to a model is one call site.
-
-## What to collect per call site (identifiers and counts ONLY)
-- id: a stable label you choose, e.g. "api/summarize.ts:42"
-- model: the model id exactly as configured
-- modelSelection: hardcoded | config | env | dynamic
-- archetype: your best guess at the work's intent \u2014 one of: ask, classify, critique, extract, generate, hunt, plan, summarize, transform
-- estInputTokens / maxInputTokens / estOutputTokens: estimate from the code (what gets concatenated into the prompt; ~4 chars per token). Worst case matters \u2014 find the biggest thing that can flow in.
-- toolCount, usesParallelToolCalls: from the tools array and how results are consumed
-- expectsStructuredOutput: true if the response is JSON.parse'd or schema-validated
-- streaming, retry (none | same-model | fallback-chain | unknown), fallbackModels
-- estCallsPerMonth: only if genuinely inferable (cron cadence, obvious traffic); omit rather than invent
-
-## Privacy contract (relay this to your human)
-Do NOT put prompt text, source code, file contents, or secrets in the extract. Identifiers and counts only. ${DESTINATION_SENTENCE}
-
-## Then
-Write the extract as JSON:
-{ "project": { "name": "...", "description": "..." }, "callSites": [ ...one object per call site... ] }
-and run:
-  npx -y @warmdrift/kgauto-check --extract extract.json
-Present the printed card verbatim \u2014 the confidence tiers (certain / likely / measurable-only) are the point: they tell your human exactly how much to trust each line, and the measurable-only section is what a one-day observe run would answer.
-
-## Sharing (optional, explicit)
-After presenting the card, you may OFFER your human: "want to send this card to kgauto so the catalog learns what real projects look like?" If \u2014 and only if \u2014 they say yes, re-run with --share. Never add --share without their explicit yes. It sends the scrubbed extract and the card, nothing else, and says exactly where they went.
-
-## Honesty rules you inherit while presenting
-- Do not soften "certain" findings or upgrade "likely" ones.
-- If a model was unknown to the catalog, say so \u2014 kgauto refuses to fabricate verdicts, and so should you.
-- Estimates you made are estimates: if a finding hinges on your token guess, say it can be firmed up by measuring.`;
-
-// src/observe-plan.ts
-var OBSERVE_DAY_PLAN = `# The one-day observe run (for you, the agent \u2014 decision stays with your human)
-
-## What it is
-One day of your project's normal traffic, observed. No routing changes: every call still goes to exactly the model your code chooses today. The observation records, per call: model, token counts in/out, cost at verified prices, latency, success/failure with a classified error code, and per-attempt rows when retries happen. Identifiers and counts \u2014 prompt text is never required.
-
-## What it answers (the measurable-only tier of your check card)
-- actual failure rate per model \u2014 including walkaway failures that green health checks miss
-- actual input-waste ratio per call site (the >85% input-share signal, measured instead of estimated)
-- which call sites dominate spend
-- the evidence base for whether a cheaper model could hold quality here (kgauto's judged eval runs on real captured cases, never on price alone)
-
-## The two honesty requirements (non-negotiable, relay both)
-1. **Destination, named before anything runs.** Your human gets one plain sentence stating exactly where outcome rows land and what is in them, BEFORE the first row is written. "Nothing is uploaded" was true of the check because it writes nothing; the observe day writes rows, so it must say where.
-2. **Observation never intervenes.** If your project uses fallback chains, observing must not pin a model and silently disable the chain \u2014 a forced pin is an intervention sold as observation. Rows are recorded per attempt, so the chain's real behaviour is what gets measured.
-
-## How to proceed
-The integration is small (the kgauto compiler's call/record path with your existing keys), but because rows now land somewhere, the wiring starts with that destination sentence and your human's explicit yes. Next step: have your human reply to whoever pointed them at kgauto \u2014 the observe day is set up per-project, together.`;
-
-// src/model-facts.ts
-import { tryGetProfile as tryGetProfile2, resolveModelAlias as resolveModelAlias2, LIBRARY_VERSION as LIBRARY_VERSION2 } from "@warmdrift/kgauto-compiler";
-function renderModelFacts(model) {
-  const canonical = resolveModelAlias2(model);
-  const p = tryGetProfile2(model);
-  if (!p) {
-    return `\`${model}\` is not in kgauto's verified catalog (lib ${LIBRARY_VERSION2}). No measured evidence exists for it here, and kgauto does not fabricate verdicts. New models enter the catalog through doc-verified onboarding.`;
-  }
-  return [
-    `# ${canonical}${canonical !== model ? ` (you asked for \`${model}\`, a provider alias)` : ""}`,
-    "",
-    `- provider: ${p.provider} \xB7 status: **${p.status}**${p.verifiedAgainstDocs ? ` \xB7 capability data verified against provider docs ${p.verifiedAgainstDocs}` : ""}`,
-    `- price: $${p.costInputPer1m}/M input \xB7 $${p.costOutputPer1m}/M output`,
-    `- limits: ${p.maxContextTokens.toLocaleString()} context \xB7 ${p.maxOutputTokens.toLocaleString()} max output \xB7 ${p.maxTools} tools`,
-    `- capabilities: parallel tool calls ${p.parallelToolCalls ? "yes" : "NO (sequential \u2014 ~10\xD7 fewer ops/step on agentic work)"} \xB7 structured output: ${p.structuredOutput} \xB7 streaming: ${p.streaming ? "yes" : "no"}`,
-    p.cliffs.length > 0 ? `- known cliffs (executable in the kgauto compiler):
-${p.cliffs.map(
-      (c) => `  - ${c.metric.replaceAll("_", " ")} \u2265 ${c.threshold.toLocaleString()}${c.whenIntent ? ` on ${c.whenIntent}` : ""} \u2192 ${c.action.replaceAll("_", " ")}`
-    ).join("\n")}` : p.probedLimits?.length ? "- known cliffs: none recorded \u2014 and see the probed limits below, which is why that is a finding rather than a blank" : "- known cliffs: none recorded (nothing measured here yet \u2014 kgauto does not invent one)",
-    // alpha.95 — measured NEGATIVES. Without these, a frontier model reads
-    // "cliffs: none recorded", which a stranger correctly hears as "you know
-    // nothing about this one" — and it was the honest reading, because every
-    // probe result landed brain-only while this lookup runs offline against
-    // the bundle. A probed limit is the one claim here that a general-purpose
-    // model cannot produce: it required running the call.
-    ...p.probedLimits?.length ? [
-      `- probed limits (we ran the call; ${p.probedLimits.length === 1 ? "this is a measurement" : "these are measurements"}, not a spec sheet):
-${p.probedLimits.map(
-        (l) => `  - ${l.metric.replaceAll("_", " ")} @ ${l.testedAt.toLocaleString()} \u2192 **${l.outcome}**. ${l.claim}${l.probeRunId ? ` (run ${l.probeRunId})` : ""}`
-      ).join("\n")}`
-    ] : [],
-    p.notes ? `- notes: ${p.notes}` : "",
-    "",
-    `_Catalog: @warmdrift/kgauto-compiler ${LIBRARY_VERSION2}, bundled locally \u2014 this lookup made no network call._`
-  ].filter(Boolean).join("\n");
-}
-
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
-var text = (t) => ({ content: [{ type: "text", text: t }] });
-function buildServer() {
-  const server = new McpServer(
-    { name: "kgauto-check", version: CHECK_VERSION },
-    { instructions: SERVER_INSTRUCTIONS }
-  );
-  server.registerTool(
-    "start_check",
-    {
-      title: "Start a kgauto check",
-      description: "Call this FIRST. Returns extraction instructions: what to read from this project and how to build the extract for run_check. The extract carries identifiers and counts only \u2014 never prompt text, code, or secrets.",
-      inputSchema: {}
-    },
-    async () => text(START_CHECK_INSTRUCTIONS)
-  );
-  server.registerTool(
-    "run_check",
-    {
-      title: "Run the check",
-      description: "Runs the deterministic kgauto check on your extract, fully offline against the bundled verified model catalog. Returns a findings card grouped by confidence tier (certain / likely / measurable-only) \u2014 present it to your human verbatim.",
-      inputSchema: { extract: ExtractSchema }
-    },
-    async ({ extract }) => {
-      const result = runCheck(extract);
-      return text(result.card);
-    }
-  );
-  server.registerTool(
-    "get_model_facts",
-    {
-      title: "Model facts",
-      description: "What kgauto's verified catalog knows about one model id: lifecycle status, doc-verified prices and limits, capability flags, known quality cliffs. Honest miss when the model is unknown \u2014 no fabricated verdicts.",
-      inputSchema: { model: z2.string().min(1) }
-    },
-    async ({ model }) => text(renderModelFacts(model))
-  );
-  server.registerTool(
-    "get_observe_day_plan",
-    {
-      title: "The one-day observe run",
-      description: "Rung 2: what a one-day, observe-only run on this project's real traffic would measure, and the two honesty requirements any setup must carry (named row destination; observation never intervenes). Ends in a human decision by design.",
-      inputSchema: {}
-    },
-    async () => text(OBSERVE_DAY_PLAN)
-  );
-  return server;
-}
-async function startStdio() {
-  const server = buildServer();
-  await server.connect(new StdioServerTransport());
-}
-
-export {
-  CallSiteSchema,
-  ExtractSchema,
-  CHECK_VERSION,
-  DESTINATION_SENTENCE,
-  runCheck,
-  renderCard,
-  SERVER_INSTRUCTIONS,
-  START_CHECK_INSTRUCTIONS,
-  OBSERVE_DAY_PLAN,
-  renderModelFacts,
-  buildServer,
-  startStdio
-};