lurqrun 0.1.6 → 0.1.7

package/dist/ingestQueue-VKN4KBIF.js

@@ -0,0 +1,35 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  drainIngestQueue,
+  enqueueIngest,
+  ingestQueueDepth,
+  resetIngestQueue,
+  runIngest
+} from "./chunk-FW6BD2NO.js";
+import "./chunk-BUALU27S.js";
+import "./chunk-LRD4GBYE.js";
+import "./chunk-BCANRN5B.js";
+import "./chunk-2VMOWSRY.js";
+import "./chunk-4ESO33J6.js";
+import "./chunk-CW5HJ3LX.js";
+import "./chunk-AHBP533R.js";
+import "./chunk-SJOVFF7B.js";
+import "./chunk-HWBBVLOT.js";
+import "./chunk-NH5I4KHH.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-WQ23REYT.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-3GHJR7XR.js";
+import "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  drainIngestQueue,
+  enqueueIngest,
+  ingestQueueDepth,
+  resetIngestQueue,
+  runIngest
+};

package/dist/install-EK3W2COX.js

@@ -0,0 +1,20 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  runSetup,
+  runningFromNpx,
+  withSetupOnMissingKey
+} from "./chunk-EA3DP5HG.js";
+import "./chunk-4ZYCIMY4.js";
+import "./chunk-TNTXWSYA.js";
+import "./chunk-4KCPOMG6.js";
+import "./chunk-UDVNA7EA.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-Y5GI7RL3.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  runSetup,
+  runningFromNpx,
+  withSetupOnMissingKey
+};

package/dist/installSkill-VQJWJVCL.js

@@ -0,0 +1,52 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  BLOCK_START,
+  SUPPORTED_AGENTS,
+  agentSpecs,
+  buildRemoteServerEntry,
+  buildRemoteTomlBlock,
+  buildServerEntry,
+  buildSkillFile,
+  buildTomlBlock,
+  installAgent,
+  installInstructions,
+  installInstructionsFile,
+  lurqInvocation,
+  printInstallReport,
+  readJsonObject,
+  removeMarkedBlock,
+  resolveAgents,
+  runInstallSkill,
+  stripTomlBlock,
+  upsertMarkedBlock,
+  writeFileAtomic,
+  writeJson
+} from "./chunk-UDVNA7EA.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-Y5GI7RL3.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  BLOCK_START,
+  SUPPORTED_AGENTS,
+  agentSpecs,
+  buildRemoteServerEntry,
+  buildRemoteTomlBlock,
+  buildServerEntry,
+  buildSkillFile,
+  buildTomlBlock,
+  installAgent,
+  installInstructions,
+  installInstructionsFile,
+  lurqInvocation,
+  printInstallReport,
+  readJsonObject,
+  removeMarkedBlock,
+  resolveAgents,
+  runInstallSkill,
+  stripTomlBlock,
+  upsertMarkedBlock,
+  writeFileAtomic,
+  writeJson
+};

package/dist/inventory-5AWSLJYU.js

@@ -0,0 +1,31 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  MAX_ITEMS,
+  MAX_TRANSITIVES,
+  attributeTree,
+  classifyServer,
+  collectInventory,
+  expandWorkspaces,
+  mcpConfigPaths,
+  readLockTree,
+  readLockfile,
+  serversFromConfig,
+  splitSpec,
+  workspacePatterns
+} from "./chunk-63MUJNZL.js";
+import "./chunk-QKGYDMWB.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  MAX_ITEMS,
+  MAX_TRANSITIVES,
+  attributeTree,
+  classifyServer,
+  collectInventory,
+  expandWorkspaces,
+  mcpConfigPaths,
+  readLockTree,
+  readLockfile,
+  serversFromConfig,
+  splitSpec,
+  workspacePatterns
+};

package/dist/local-XPZMRH5R.js

@@ -0,0 +1,13 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  LocalSandbox,
+  npmInstallArgs,
+  smokeScript
+} from "./chunk-C6GLE626.js";
+import "./chunk-GE37NVLN.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  LocalSandbox,
+  npmInstallArgs,
+  smokeScript
+};

package/dist/mcp-3JHD5SUZ.js

@@ -0,0 +1,472 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  sniffMissingEnv
+} from "./chunk-U5AT3TD4.js";
+import "./chunk-6AAEVQ7I.js";
+import {
+  formatError
+} from "./chunk-MHUEVBVO.js";
+import {
+  configRequestLine,
+  fetchServerManifest,
+  missingConfig
+} from "./chunk-LEGPB7DO.js";
+import {
+  MCP_TIER,
+  mcpSurface,
+  surfaceHash
+} from "./chunk-6EQ3ARXA.js";
+import "./chunk-SHCEBP3J.js";
+import {
+  bumpSurfaceAttempt,
+  dropSurfaceQueue,
+  enqueuePreviousSurface,
+  enqueueSurface,
+  getPendingSurfaces,
+  isExtractionCached,
+  mcpSurfaceRef,
+  recordObservation,
+  storeSurface,
+  upsertClaim,
+  upsertEntity
+} from "./chunk-LO35HLQZ.js";
+import {
+  getSandbox
+} from "./chunk-I2JUKN6Z.js";
+import "./chunk-C6GLE626.js";
+import "./chunk-GE37NVLN.js";
+import {
+  getPackageVersions
+} from "./chunk-NH5I4KHH.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/pipeline/mcp.ts
+init_esm_shims();
+
+// src/graph/oracles/mcpServer.ts
+init_esm_shims();
+var PROTOCOL_VERSION = "2026-07-28";
+var HANDSHAKE_TIMEOUT_MS = 45e3;
+var EVIDENCE_MAX = 800;
+var MAX_PAGES = 50;
+function probeScript(pkg, launchArgs = [], env = {}) {
+  return `
+const { spawn } = require('node:child_process');
+const { readFileSync } = require('node:fs');
+const { join, basename } = require('node:path');
+
+const PKG = ${JSON.stringify(pkg)};
+const EXTRA_ARGS = ${JSON.stringify(launchArgs)};
+const EXTRA_ENV = ${JSON.stringify(env)};
+
+/**
+ * Resolve the server's entry point from its installed manifest.
+ *
+ * The package name is NOT the bin name often enough to matter \u2014
+ * @modelcontextprotocol/server-filesystem ships 'mcp-server-filesystem' \u2014 so
+ * 'npx <pkg>' misses, and the miss looks exactly like a server that fails to
+ * start. Read node_modules directly rather than require.resolve: an "exports"
+ * map is allowed to hide ./package.json, and a fresh install always has the
+ * flat path.
+ */
+function launch() {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(join(process.cwd(), 'node_modules', PKG, 'package.json'), 'utf8'));
+  } catch {
+    return { command: 'npx', args: ['--no-install', PKG] };
+  }
+  let rel = null;
+  if (typeof manifest.bin === 'string') rel = manifest.bin;
+  else if (manifest.bin && typeof manifest.bin === 'object') {
+    const keys = Object.keys(manifest.bin);
+    rel = manifest.bin[basename(PKG)] || manifest.bin[keys[0]];
+  }
+  if (!rel) rel = manifest.main;
+  if (!rel) return { command: 'npx', args: ['--no-install', PKG] };
+  return { command: process.execPath, args: [join(process.cwd(), 'node_modules', PKG, rel)] };
+}
+
+const { command, args } = launch();
+// Extra arguments go AFTER the resolved entry point. A large share of servers
+// ship a multi-command CLI where MCP is one verb, so launching the bin bare
+// prints a help banner and exits \u2014 which is indistinguishable from a server
+// that cannot start unless the verb is supplied.
+// Env is embedded in the script rather than plumbed through the sandbox
+// interface, so both drivers get it with no contract change.
+const child = spawn(command, args.concat(EXTRA_ARGS), {
+  stdio: ['pipe', 'pipe', 'pipe'],
+  env: Object.assign({}, process.env, EXTRA_ENV),
+});
+
+let buf = '', done = false, stderr = '';
+/**
+ * Emit the single result line and stop.
+ *
+ * The write callback is load-bearing. process.exit() abandons whatever has not
+ * yet drained from a pipe-backed stdout, and Node's pipe writes are async \u2014 so
+ * exiting on the next line silently truncates the payload at the pipe buffer
+ * (8 KiB on Linux and macOS). A 13-tool server fits and a 9-tool server with
+ * large nested schemas does not, which turned "this server documents its inputs
+ * thoroughly" into "this server is unreachable": the truncated JSON fails to
+ * parse and the caller records verified_false about a server that answered
+ * perfectly. Exit only once the bytes are actually gone.
+ */
+const out = (o) => {
+  if (done) return;
+  done = true;
+  try { child.kill('SIGKILL'); } catch {}
+  process.stdout.write(JSON.stringify(o) + '\\n', () => process.exit(0));
+};
+const timer = setTimeout(() => out({ ok: false, stage: 'initialize', error: 'timeout awaiting handshake' }), ${HANDSHAKE_TIMEOUT_MS - 5e3});
+const send = (msg) => { try { child.stdin.write(JSON.stringify(msg) + '\\n'); } catch (e) { out({ ok: false, stage: 'spawn', error: 'stdin closed: ' + String(e && e.message || e) }); } };
+
+let serverInfo, protocolVersion;
+let tools = [], pages = 0, nextId = 2;
+
+// Pull every page. A single unpaginated read is the difference between "this
+// server exposes 12 tools" and "this server exposes the first 12 of 40" \u2014 and
+// the second, diffed against a full read, reports 28 tools as removed.
+const listTools = (cursor) => send({
+  jsonrpc: '2.0', id: nextId, method: 'tools/list',
+  params: cursor ? { cursor: cursor } : {},
+});
+
+child.on('error', (e) => out({ ok: false, stage: 'spawn', error: String(e && e.message || e) }));
+child.stderr.on('data', (d) => { stderr += d.toString().slice(0, 2000); });
+
+child.stdout.on('data', (d) => {
+  buf += d.toString();
+  let i;
+  while ((i = buf.indexOf('\\n')) >= 0) {
+    const line = buf.slice(0, i).trim();
+    buf = buf.slice(i + 1);
+    if (!line) continue;
+    let msg;
+    try { msg = JSON.parse(line); } catch { continue; }  // servers log non-JSON to stdout
+    if (msg.id === 1) {
+      if (msg.error) return out({ ok: false, stage: 'initialize', error: JSON.stringify(msg.error) });
+      serverInfo = msg.result && msg.result.serverInfo;
+      protocolVersion = msg.result && msg.result.protocolVersion;
+      send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+      listTools(null);
+    } else if (msg.id === nextId) {
+      if (msg.error) return out({ ok: false, stage: 'tools/list', error: JSON.stringify(msg.error), serverInfo, protocolVersion });
+      const result = msg.result || {};
+      pages++;
+      for (const t of result.tools || []) {
+        tools.push({
+          name: t.name,
+          title: t.title,
+          description: t.description,
+          inputSchema: t.inputSchema,
+          outputSchema: t.outputSchema,
+          annotations: t.annotations,
+        });
+      }
+      if (result.nextCursor && pages < ${MAX_PAGES}) { nextId++; listTools(result.nextCursor); return; }
+      clearTimeout(timer);
+      return out({
+        ok: true, stage: 'done', serverInfo, protocolVersion, tools, pages,
+        truncated: Boolean(result.nextCursor),
+      });
+    }
+  }
+});
+
+child.on('exit', (code) => out({ ok: false, stage: 'spawn', error: 'exited ' + code + (stderr ? ': ' + stderr.slice(0, 400) : '') }));
+
+send({
+  jsonrpc: '2.0', id: 1, method: 'initialize',
+  params: {
+    protocolVersion: ${JSON.stringify(PROTOCOL_VERSION)},
+    capabilities: {},
+    clientInfo: { name: 'lurq-oracle', version: '1' },
+  },
+});
+`.trim();
+}
+function parseProbeOutput(stdout) {
+  const lines = stdout.trim().split("\n").reverse();
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t.startsWith("{")) continue;
+    try {
+      const parsed = JSON.parse(t);
+      if (typeof parsed.ok === "boolean") return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+var LAUNCH_VERBS = ["mcp", "serve", "--stdio"];
+async function attempt(sandbox, pkg, version, args, env) {
+  const res = await sandbox.exec(`node -e ${shellQuote(probeScript(pkg, args, env))}`, {
+    install: [{ name: pkg, version }],
+    timeoutMs: HANDSHAKE_TIMEOUT_MS
+  });
+  return { probe: parseProbeOutput(res.stdout), stderr: res.stderr };
+}
+async function probeMcpServer(sandbox, pkg, version, opts = {}) {
+  const ladder = opts.args?.length ? [opts.args] : [[]];
+  for (const verb of LAUNCH_VERBS) ladder.push([verb]);
+  let last = { probe: null, stderr: "" };
+  for (const args of ladder) {
+    try {
+      const res = await attempt(sandbox, pkg, version, args, opts.env ?? {});
+      if (res.probe?.ok) return { ...res, launchedWith: args };
+      last = res;
+    } catch (err) {
+      throw new Error(`sandbox failure: ${String(err)}`);
+    }
+  }
+  return { ...last, launchedWith: [] };
+}
+var mcpServerOracle = {
+  id: "mcp_server.handshake",
+  version: "2",
+  // v2: full tool schemas + paginated tools/list
+  kind: "mcp_server",
+  ttlHours: 24 * 14,
+  // spec §2: on publish, else 14 days
+  rule: "Install the package, speak MCP over stdio (initialize \u2192 tools/list, all pages); failure is install error, handshake timeout, JSON-RPC error, or malformed tool list.",
+  async run(target, _env, sandbox) {
+    const started = Date.now();
+    const { probe, stderr } = await probeMcpServer(sandbox, target.name, target.version ?? null);
+    const observations = [];
+    const discovered = [];
+    if (!probe) {
+      observations.push({
+        relation: "initializes",
+        verdict: "verified_false",
+        evidence: truncate(`no probe output. stderr: ${stderr}`)
+      });
+      return { observations, costMillis: Date.now() - started };
+    }
+    if (!probe.ok) {
+      observations.push({
+        relation: "initializes",
+        verdict: "verified_false",
+        evidence: truncate(`stage=${probe.stage} ${probe.error ?? ""}`)
+      });
+      return { observations, costMillis: Date.now() - started };
+    }
+    if (probe.truncated) {
+      observations.push({
+        relation: "initializes",
+        verdict: "unverifiable",
+        evidence: truncate(
+          `tools/list still paginating after ${MAX_PAGES} pages (${probe.tools?.length ?? 0} tools read); list is incomplete`
+        )
+      });
+      return { observations, costMillis: Date.now() - started };
+    }
+    observations.push({
+      relation: "initializes",
+      verdict: "verified_true",
+      evidence: truncate(
+        `serverInfo=${probe.serverInfo?.name ?? "?"}@${probe.serverInfo?.version ?? "?"} protocol=${probe.protocolVersion ?? "?"} tools=${probe.tools?.length ?? 0} pages=${probe.pages ?? 1}`
+      )
+    });
+    for (const tool of probe.tools ?? []) {
+      const ref = {
+        kind: "mcp_tool",
+        namespace: target.namespace,
+        name: `${target.name}#${tool.name}`,
+        version: target.version ?? null
+      };
+      discovered.push(ref);
+      observations.push({
+        object: ref,
+        relation: "provides",
+        verdict: "verified_true",
+        evidence: truncate(tool.description ?? tool.name)
+      });
+    }
+    return { observations, discovered, costMillis: Date.now() - started };
+  }
+};
+function truncate(s) {
+  return s.replace(/\s+/g, " ").trim().slice(0, EVIDENCE_MAX);
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/pipeline/mcp.ts
+var VERSION_LOOKBACK = 50;
+var EXTRACTOR_VERSION = "2";
+var PLACEHOLDER_VALUE = "lurq-placeholder-not-a-real-credential";
+var MAX_ATTEMPTS = 3;
+var MCP_PER_CYCLE = 3;
+async function extractAndStoreMcp(db, server, version, opts = {}) {
+  const ref = mcpSurfaceRef(server, version);
+  const manifest = await fetchServerManifest(server);
+  if (manifest?.remoteOnly) {
+    return {
+      outcome: "not_stdio",
+      tools: [],
+      reason: `published only as a remote ${manifest.transport ?? "endpoint"}; there is no package to install and probe`
+    };
+  }
+  const missing = missingConfig(manifest, opts.env);
+  const placeholders = {};
+  for (const m of missing) placeholders[m.name] = PLACEHOLDER_VALUE;
+  const sandbox = opts.sandbox ?? await getSandbox();
+  const { probe, stderr } = await probeMcpServer(sandbox, server, version, {
+    args: manifest?.args ?? [],
+    env: placeholders
+  });
+  if (missing.length > 0 && !probe?.ok) {
+    return {
+      outcome: "needs_config",
+      tools: [],
+      reason: configRequestLine(server, missing),
+      missing
+    };
+  }
+  if (!probe || !probe.ok) {
+    const reason = probe ? `stage=${probe.stage} ${probe.error ?? ""}`.slice(0, 300) : `no probe output: ${stderr.slice(0, 200)}`;
+    const sniffed = sniffMissingEnv(`${probe?.error ?? ""} ${stderr}`);
+    if (sniffed) {
+      const inferred = [
+        { name: sniffed, description: null, required: true, secret: true, format: null }
+      ];
+      return {
+        outcome: "needs_config",
+        tools: [],
+        reason: `server did not start and its output names ${sniffed} as required (inferred from the server's own error, not a published manifest)`,
+        missing: inferred
+      };
+    }
+    await recordUnreachable(db, ref, reason);
+    return { outcome: "unreachable", tools: [], reason };
+  }
+  if (probe.truncated) {
+    return {
+      outcome: "truncated",
+      tools: probe.tools ?? [],
+      reason: "tools/list still paginating at the page ceiling; list incomplete"
+    };
+  }
+  const tools = probe.tools ?? [];
+  const hash = surfaceHash(tools);
+  if (await isExtractionCached(db, ref, hash, EXTRACTOR_VERSION, MCP_TIER)) {
+    return { outcome: "cached", tools, reason: null };
+  }
+  const res = await storeSurface(db, mcpSurface(server, version, tools), {
+    artifactHash: hash,
+    extractorVersion: EXTRACTOR_VERSION,
+    ref,
+    oracleId: mcpServerOracle.id
+  });
+  await queueNpmIngest(db, server);
+  return {
+    outcome: res.verdict === "undeclared" ? "undeclared" : "stored",
+    tools,
+    reason: res.verdict === "undeclared" ? "server listed no tools" : null
+  };
+}
+async function recordUnreachable(db, ref, reason) {
+  const entity = await upsertEntity(db, ref, 0);
+  const claim = await upsertClaim(db, {
+    subjectId: entity.id,
+    relation: "initializes",
+    environmentId: null,
+    tenantId: 0
+  });
+  await recordObservation(db, {
+    claimId: claim.id,
+    verdict: "verified_false",
+    class: "executed",
+    tier: MCP_TIER,
+    evidence: reason,
+    oracleId: mcpServerOracle.id,
+    oracleVer: EXTRACTOR_VERSION
+  });
+}
+async function queueNpmIngest(db, name) {
+  try {
+    const { enqueueIngest } = await import("./ingestQueue-VKN4KBIF.js");
+    enqueueIngest(db, name, null);
+  } catch (err) {
+    logger.debug(`mcp: npm ingest enqueue failed for ${name}: ${formatError(err)}`);
+  }
+}
+async function drainMcpQueue(db, opts = {}) {
+  const pending = await getPendingSurfaces(db, opts.limit ?? MCP_PER_CYCLE, "mcp_server");
+  const s = {
+    drained: 0,
+    stored: 0,
+    cached: 0,
+    undeclared: 0,
+    unreachable: 0,
+    needs_config: 0,
+    not_stdio: 0,
+    truncated: 0,
+    failed: 0,
+    backfilled: 0
+  };
+  for (const item of pending) {
+    s.drained++;
+    try {
+      const { outcome, reason } = await extractAndStoreMcp(db, item.packageName, item.version, {
+        sandbox: opts.sandbox
+      });
+      s[outcome]++;
+      if (reason) {
+        logger.info(
+          { server: item.packageName, version: item.version, outcome, reason },
+          "mcp: no surface stored"
+        );
+      }
+      if (item.version && (outcome === "stored" || outcome === "cached")) {
+        await enqueuePreviousSurface(
+          db,
+          item.packageName,
+          item.version,
+          await getPackageVersions(db, item.packageName, VERSION_LOOKBACK),
+          "mcp_server"
+        ).then(
+          (queued) => {
+            if (queued) s.backfilled++;
+          },
+          (err) => logger.warn(
+            { server: item.packageName, err: formatError(err) },
+            "mcp: predecessor backfill could not be queued"
+          )
+        );
+      }
+      await dropSurfaceQueue(db, item.id);
+    } catch (err) {
+      s.failed++;
+      if (item.attempts + 1 >= MAX_ATTEMPTS) await dropSurfaceQueue(db, item.id);
+      else await bumpSurfaceAttempt(db, item.id);
+      logger.warn(
+        { spec: item.specKey, attempts: item.attempts + 1, err: formatError(err) },
+        "mcp surface probe failed"
+      );
+    }
+  }
+  return s;
+}
+async function enqueueMcpServer(db, server, version) {
+  await enqueueSurface(db, server, version, "mcp_server");
+}
+export {
+  MCP_PER_CYCLE,
+  drainMcpQueue,
+  enqueueMcpServer,
+  extractAndStoreMcp,
+  sniffMissingEnv
+};

package/dist/mcpHandlers-QFN4MCFL.js

@@ -0,0 +1,22 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  handleMcpDrift,
+  handleMcpSurface
+} from "./chunk-3N3Q3DSW.js";
+import "./chunk-DB2VF5UD.js";
+import "./chunk-LEGPB7DO.js";
+import {
+  summarizeDrift
+} from "./chunk-6EQ3ARXA.js";
+import "./chunk-SHCEBP3J.js";
+import "./chunk-LO35HLQZ.js";
+import "./chunk-HWBBVLOT.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  handleMcpDrift,
+  handleMcpSurface,
+  summarizeDrift as summarize
+};