@productbrain/mcp 0.0.1-beta.191 → 0.0.1-beta.1912

package/dist/chunk-6JNK5DIZ.js

@@ -0,0 +1,1052 @@
+// src/analytics.ts
+import { userInfo } from "os";
+import { PostHog } from "posthog-node";
+var client = null;
+var distinctId = "anonymous";
+var POSTHOG_HOST = "https://eu.i.posthog.com";
+function log(msg) {
+  if (process.env.MCP_DEBUG === "1") {
+    process.stderr.write(msg);
+  }
+}
+function getBuildTimeKey() {
+  try {
+    return "";
+  } catch {
+    return "";
+  }
+}
+function initAnalytics() {
+  const apiKey = process.env.POSTHOG_MCP_KEY || getBuildTimeKey();
+  if (!apiKey) {
+    log("[MCP-ANALYTICS] No PostHog key \u2014 tracking disabled (set SYNERGYOS_POSTHOG_KEY at build time for publish)\n");
+    return;
+  }
+  client = new PostHog(apiKey, {
+    host: POSTHOG_HOST,
+    flushAt: 1,
+    flushInterval: 5e3,
+    featureFlagsPollingInterval: 3e4
+  });
+  distinctId = process.env.MCP_USER_ID || fallbackDistinctId();
+  log(`[MCP-ANALYTICS] Initialized \u2014 host=${POSTHOG_HOST} distinctId=${distinctId}
+`);
+}
+function fallbackDistinctId() {
+  try {
+    return userInfo().username;
+  } catch {
+    return `os-${process.pid}`;
+  }
+}
+function trackSessionStarted(workspaceId, serverVersion) {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_session_started",
+    properties: {
+      workspace_id: workspaceId,
+      server_version: serverVersion,
+      source: "mcp-server",
+      $groups: { workspace: workspaceId }
+    }
+  });
+}
+function trackToolCall(fn, status, durationMs, workspaceId, errorMsg) {
+  const properties = {
+    tool: fn,
+    status,
+    duration_ms: durationMs,
+    workspace_id: workspaceId,
+    source: "mcp-server",
+    $groups: { workspace: workspaceId }
+  };
+  if (errorMsg) properties.error = errorMsg;
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_tool_called",
+    properties
+  });
+}
+function trackSetupStarted() {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_setup_started",
+    properties: {
+      source: "mcp-server",
+      platform: process.platform
+    }
+  });
+}
+function trackSetupCompleted(chosenClient, outcome) {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_setup_completed",
+    properties: {
+      client: chosenClient,
+      outcome,
+      source: "mcp-server",
+      platform: process.platform
+    }
+  });
+}
+function trackQualityVerdict(workspaceId, props) {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "quality_verdict_generated",
+    properties: {
+      ...props,
+      workspace_id: workspaceId,
+      source_system: "mcp-server",
+      $groups: { workspace: workspaceId }
+    }
+  });
+}
+function trackQualityCheck(workspaceId, props) {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "quality_verdict_checked",
+    properties: {
+      ...props,
+      workspace_id: workspaceId,
+      source_system: "mcp-server",
+      $groups: { workspace: workspaceId }
+    }
+  });
+}
+function trackCaptureClassifierEvent(event, workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event,
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackCaptureClassifierEvaluated(workspaceId, props) {
+  trackCaptureClassifierEvent("mcp_capture_classifier_evaluated", workspaceId, props);
+}
+function trackCaptureClassifierAutoRouted(workspaceId, props) {
+  trackCaptureClassifierEvent("mcp_capture_classifier_auto_routed", workspaceId, props);
+}
+function trackCaptureClassifierFallback(workspaceId, props) {
+  trackCaptureClassifierEvent("mcp_capture_classifier_fallback", workspaceId, props);
+}
+function trackChainEntryCommitted(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "chain_entry_committed",
+      properties: {
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId },
+        ...props
+      }
+    });
+  } catch {
+  }
+}
+function trackKnowledgeGap(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "knowledge_gap_detected",
+      properties: {
+        ...props,
+        query: props.query.slice(0, 200),
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackCaptureQualityHints(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "mcp_capture_quality_hints",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackCaptureRelationSuggestions(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "mcp_capture_relation_suggestions",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackCollectionClassified(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "collection_classified",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackFieldGuidanceApplied(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "field_guidance_applied",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackFieldQualityWarning(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "field_quality_warning",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackSessionCaptureRate(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "session_capture_rate",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackZeroCaptureAuditFired(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "zero_capture_audit_fired",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackCaptureContractMiss(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "capture_contract_miss",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackWriteBackHintServed(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "write_back_hint_served",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackCommitErrorByCode(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "commit_error_by_code",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function trackClassifierDivergence(workspaceId, props) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "classifier_divergence",
+      properties: {
+        ...props,
+        workspace_id: workspaceId,
+        source_system: "mcp-server",
+        $groups: { workspace: workspaceId }
+      }
+    });
+  } catch {
+  }
+}
+function getPostHogClient() {
+  return client;
+}
+async function shutdownAnalytics() {
+  await client?.shutdown();
+}
+
+// src/auth.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+function hashKey(key) {
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+var requestStore = new AsyncLocalStorage();
+function runWithAuth(auth, fn) {
+  return requestStore.run(auth, fn);
+}
+function getRequestApiKey() {
+  return requestStore.getStore()?.apiKey;
+}
+var SESSION_TTL_MS = 30 * 60 * 1e3;
+var MAX_KEYS = 100;
+var keyStateMap = /* @__PURE__ */ new Map();
+function newKeyState() {
+  return {
+    workspaceId: null,
+    workspaceSlug: null,
+    workspaceName: null,
+    workspaceCreatedAt: null,
+    workspaceGovernanceMode: null,
+    agentSessionId: null,
+    apiKeyId: null,
+    apiKeyScope: "readwrite",
+    sessionOriented: false,
+    sessionClosed: false,
+    lastAccess: Date.now(),
+    deploymentUrl: null
+  };
+}
+function getKeyState(apiKey) {
+  let s = keyStateMap.get(apiKey);
+  if (!s) {
+    s = newKeyState();
+    keyStateMap.set(apiKey, s);
+    evictStale();
+  }
+  s.lastAccess = Date.now();
+  return s;
+}
+function evictStale() {
+  if (keyStateMap.size <= MAX_KEYS) return;
+  const now = Date.now();
+  for (const [key, s] of keyStateMap) {
+    if (now - s.lastAccess > SESSION_TTL_MS) keyStateMap.delete(key);
+  }
+  if (keyStateMap.size > MAX_KEYS) {
+    const sorted = [...keyStateMap.entries()].sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+    for (let i = 0; i < sorted.length - MAX_KEYS; i++) {
+      keyStateMap.delete(sorted[i][0]);
+    }
+  }
+}
+
+// src/cli/config-writer.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir, platform } from "os";
+var SERVER_ENTRY_KEY = "Product Brain";
+var LEGACY_ENTRY_KEY = "productbrain";
+var MCP_NPX_PACKAGE = "@productbrain/mcp@beta";
+function buildServerEntry(apiKey) {
+  return {
+    command: "npx",
+    args: ["-y", MCP_NPX_PACKAGE],
+    env: { PRODUCTBRAIN_API_KEY: apiKey }
+  };
+}
+function getCursorConfigPath() {
+  return join(process.cwd(), ".cursor", "mcp.json");
+}
+function getClaudeDesktopConfigPath() {
+  const os = platform();
+  if (os === "darwin") {
+    return join(
+      homedir(),
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  }
+  if (os === "win32") {
+    const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    return join(appData, "Claude", "claude_desktop_config.json");
+  }
+  return null;
+}
+function resolveClient(name) {
+  if (name === "Cursor") {
+    return { name, configPath: getCursorConfigPath() };
+  }
+  const configPath = getClaudeDesktopConfigPath();
+  return configPath ? { name, configPath } : null;
+}
+function readJsonSafe(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function writeClientConfig(client2, apiKey) {
+  const config = readJsonSafe(client2.configPath);
+  const serversKey = "mcpServers";
+  if (!config[serversKey]) config[serversKey] = {};
+  if (config[serversKey][LEGACY_ENTRY_KEY]) {
+    const legacy = config[serversKey][LEGACY_ENTRY_KEY];
+    config[serversKey][SERVER_ENTRY_KEY] = {
+      ...buildServerEntry(apiKey),
+      env: { ...legacy.env, PRODUCTBRAIN_API_KEY: legacy.env?.PRODUCTBRAIN_API_KEY ?? apiKey }
+    };
+    delete config[serversKey][LEGACY_ENTRY_KEY];
+  } else {
+    const existing = config[serversKey][SERVER_ENTRY_KEY];
+    config[serversKey][SERVER_ENTRY_KEY] = existing ? { ...existing, env: { ...existing.env, PRODUCTBRAIN_API_KEY: apiKey } } : buildServerEntry(apiKey);
+  }
+  const dir = dirname(client2.configPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(client2.configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return true;
+}
+
+// src/client.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var toolContextStore = new AsyncLocalStorage2();
+function runWithToolContext(ctx, fn) {
+  return toolContextStore.run(ctx, fn);
+}
+function getToolContext() {
+  return toolContextStore.getStore() ?? null;
+}
+var DEFAULT_CLOUD_URL = "https://gateway.productbrain.io";
+var KernelCallError = class extends Error {
+  status;
+  code;
+  /** WP-316 S1a: Structured commit validation — required field keys missing from entry.data. */
+  missingRequiredFields;
+  /** WP-316 S1a: Structured commit validation — field-level data errors. */
+  fieldErrors;
+  /**
+   * WP-465 slice ⑤: structured diagnostics carried by an `ok:false` kernel envelope
+   * (e.g. `coherencyRefusals`, `blockers`). The gateway forwards these verbatim at
+   * HTTP 200; without preserving them here a refused/blocked envelope would collapse
+   * into a bare code+message and the caller could not surface the per-offender routes.
+   */
+  diagnostics;
+  constructor(message, status, code, missingRequiredFields, fieldErrors, diagnostics) {
+    super(message);
+    this.name = "KernelCallError";
+    this.status = status;
+    this.code = code;
+    this.missingRequiredFields = missingRequiredFields;
+    this.fieldErrors = fieldErrors;
+    this.diagnostics = diagnostics;
+  }
+};
+var CACHE_TTL_MS = 6e4;
+var CACHEABLE_FNS = [
+  "chain.getOrientEntries",
+  "chain.gatherContext",
+  "chain.graphGatherContext",
+  "chain.taskAwareGatherContext",
+  "chain.journeyAwareGatherContext",
+  "chain.assembleBuildContext"
+];
+function isCacheable(fn) {
+  return CACHEABLE_FNS.includes(fn);
+}
+var READ_PATTERN = /^(chain\.(get|list|search|batchGet|gather|graph|task|journey|assemble|workspace|score|absence)|chainwork\.(get|list|score)|maps\.(get|list)|gitchain\.(get|list|diff|history|runGate))/i;
+function isWrite(fn) {
+  if (fn.startsWith("agent.")) return false;
+  return !READ_PATTERN.test(fn);
+}
+var readCache = /* @__PURE__ */ new Map();
+function cacheKey(fn, args) {
+  return `${fn}:${JSON.stringify(args)}`;
+}
+function getCached(fn, args) {
+  if (!isCacheable(fn)) return void 0;
+  const key = cacheKey(fn, args);
+  const entry = readCache.get(key);
+  if (!entry || Date.now() > entry.expiresAt) {
+    if (entry) readCache.delete(key);
+    return void 0;
+  }
+  return entry.data;
+}
+function setCached(fn, args, data) {
+  if (!isCacheable(fn)) return;
+  const key = cacheKey(fn, args);
+  readCache.set(key, { data, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+function invalidateReadCache() {
+  readCache.clear();
+}
+var _stdioState = {
+  workspaceId: null,
+  workspaceSlug: null,
+  workspaceName: null,
+  workspaceCreatedAt: null,
+  workspaceGovernanceMode: null,
+  agentSessionId: null,
+  apiKeyId: null,
+  apiKeyScope: "readwrite",
+  sessionOriented: false,
+  sessionClosed: false,
+  lastAccess: 0,
+  deploymentUrl: null
+};
+function state() {
+  const reqKey = getRequestApiKey();
+  if (reqKey) return getKeyState(reqKey);
+  return _stdioState;
+}
+function cacheScope() {
+  const key = getRequestApiKey();
+  return key ? hashKey(key) : "stdio";
+}
+function getActiveApiKey() {
+  const fromRequest = getRequestApiKey();
+  if (fromRequest) return fromRequest;
+  const fromEnv = process.env.PRODUCTBRAIN_API_KEY;
+  if (!fromEnv) throw new Error("No API key available \u2014 set PRODUCTBRAIN_API_KEY or provide Bearer token");
+  return fromEnv;
+}
+function getAgentSessionId() {
+  return state().agentSessionId;
+}
+function isSessionOriented() {
+  return state().sessionOriented;
+}
+function setSessionOriented(value) {
+  state().sessionOriented = value;
+}
+function getApiKeyScope() {
+  return state().apiKeyScope;
+}
+async function startAgentSession() {
+  const workspaceId = await getWorkspaceId();
+  const s = state();
+  if (!s.apiKeyId) {
+    throw new Error("Cannot start session: API key ID not resolved. Ensure workspace resolution completed.");
+  }
+  const result = await kernelCall("agent.startSession", {
+    workspaceId,
+    apiKeyId: s.apiKeyId,
+    clientKind: "mcp"
+  });
+  if (s.agentSessionId) {
+    resetTouchThrottle(s.agentSessionId);
+  }
+  s.agentSessionId = result.sessionId;
+  s.apiKeyScope = result.toolsScope;
+  s.sessionOriented = false;
+  s.sessionClosed = false;
+  resetTouchThrottle(result.sessionId);
+  return result;
+}
+async function closeAgentSession() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  const sessionId = s.agentSessionId;
+  try {
+    await kernelCall("agent.closeSession", {
+      sessionId,
+      status: "closed"
+    });
+  } finally {
+    resetTouchThrottle(sessionId);
+    s.sessionClosed = true;
+    s.agentSessionId = null;
+    s.sessionOriented = false;
+  }
+}
+async function orphanAgentSession() {
+  const s = state();
+  if (!s.agentSessionId) return;
+  const sessionId = s.agentSessionId;
+  try {
+    await kernelCall("agent.closeSession", {
+      sessionId,
+      status: "orphaned"
+    });
+  } catch {
+  } finally {
+    resetTouchThrottle(sessionId);
+    s.agentSessionId = null;
+    s.sessionOriented = false;
+  }
+}
+var _lastTouchAtBySession = /* @__PURE__ */ new Map();
+var TOUCH_THROTTLE_MS = 5e3;
+function touchSessionActivity() {
+  const s = state();
+  const sessionId = s.agentSessionId;
+  if (!sessionId) return;
+  const now = Date.now();
+  const lastTouchAt = _lastTouchAtBySession.get(sessionId) ?? 0;
+  if (now - lastTouchAt < TOUCH_THROTTLE_MS) return;
+  _lastTouchAtBySession.set(sessionId, now);
+  kernelCall("agent.touchSession", {
+    sessionId
+  }).catch(() => {
+  });
+}
+function resetTouchThrottle(sessionId) {
+  if (sessionId) {
+    _lastTouchAtBySession.delete(sessionId);
+    return;
+  }
+  _lastTouchAtBySession.clear();
+}
+async function recordSessionActivity(activity) {
+  const s = state();
+  if (!s.agentSessionId) return;
+  try {
+    await kernelCall("agent.recordActivity", {
+      sessionId: s.agentSessionId,
+      ...activity
+    });
+  } catch {
+  }
+}
+var AUDIT_BUFFER_SIZE = 50;
+var auditBuffer = [];
+function bootstrap() {
+  const explicit = process.env.CONVEX_SITE_URL ?? process.env.PRODUCTBRAIN_URL;
+  process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+  warnOnProdFallthrough(process.env.CONVEX_SITE_URL, { explicit: explicit != null });
+  const pbKey = process.env.PRODUCTBRAIN_API_KEY;
+  if (!pbKey?.startsWith("pb_sk_")) {
+    process.stderr.write(
+      "[MCP] Warning: PRODUCTBRAIN_API_KEY is not set or invalid. Tool calls will fail until a valid key is provided.\n"
+    );
+  }
+}
+function bootstrapHttp() {
+  const explicit = process.env.CONVEX_SITE_URL ?? process.env.PRODUCTBRAIN_URL;
+  process.env.CONVEX_SITE_URL ??= process.env.PRODUCTBRAIN_URL ?? DEFAULT_CLOUD_URL;
+  warnOnProdFallthrough(process.env.CONVEX_SITE_URL, { explicit: explicit != null });
+}
+function parseFallbackUrls() {
+  const raw = process.env.CONVEX_FALLBACK_URLS;
+  if (!raw) return [];
+  return raw.split(",").map((u) => u.trim()).filter(Boolean);
+}
+async function resolveDeploymentUrl() {
+  const s = state();
+  if (s.deploymentUrl) return s.deploymentUrl;
+  const primaryUrl = (process.env.CONVEX_SITE_URL ?? DEFAULT_CLOUD_URL).replace(/\/$/, "");
+  const fallbacks = parseFallbackUrls();
+  if (fallbacks.length === 0) {
+    return primaryUrl;
+  }
+  const candidates = [primaryUrl, ...fallbacks.map((u) => u.replace(/\/$/, ""))];
+  let apiKey;
+  try {
+    apiKey = getActiveApiKey();
+  } catch {
+    return primaryUrl;
+  }
+  for (const candidate of candidates) {
+    try {
+      const probeRes = await fetch(`${candidate}/api/key-check`, {
+        method: "POST",
+        headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (probeRes.ok) {
+        const data = await probeRes.json();
+        if (data.ok) {
+          s.deploymentUrl = candidate;
+          return candidate;
+        }
+      }
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+function shouldLogAudit(status) {
+  return status === "error" || process.env.MCP_DEBUG === "1";
+}
+function audit(fn, status, durationMs, errorMsg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const workspace = state().workspaceId ?? "unresolved";
+  const toolCtx = getToolContext();
+  const entry = { ts, fn, workspace, status, durationMs };
+  if (errorMsg) entry.error = errorMsg;
+  if (toolCtx) entry.toolContext = toolCtx;
+  auditBuffer.push(entry);
+  if (auditBuffer.length > AUDIT_BUFFER_SIZE) auditBuffer.shift();
+  trackToolCall(fn, status, durationMs, workspace, errorMsg);
+  if (!shouldLogAudit(status)) return;
+  const base = `[MCP-AUDIT] ${ts} fn=${fn} workspace=${workspace} status=${status} duration=${durationMs}ms`;
+  if (status === "error" && errorMsg) {
+    process.stderr.write(`${base} error=${JSON.stringify(errorMsg)}
+`);
+  } else {
+    process.stderr.write(`${base}
+`);
+  }
+}
+function getAuditLog() {
+  return auditBuffer;
+}
+var TOUCH_EXCLUDED = /* @__PURE__ */ new Set([
+  "agent.touchSession",
+  "agent.startSession",
+  "agent.markOriented",
+  "agent.recordActivity",
+  "agent.recordWrapup",
+  "agent.closeSession",
+  // WP-376 α.3: orient byte report is itself a heartbeat-equivalent observability
+  // write that already patches the same agentSessions row. A follow-up touchSession
+  // would create a redundant second write per orient call (DEC-50 OCC anti-pattern).
+  "agent.reportOrientMetric"
+]);
+var MCP_TELEMETRY_SOURCE = "mcp";
+async function callGateway(fn, args) {
+  const siteUrl = await resolveDeploymentUrl();
+  const apiKey = getActiveApiKey();
+  const start = Date.now();
+  let res;
+  try {
+    res = await fetch(`${siteUrl}/api/aki`, {
+      method: "POST",
+      signal: AbortSignal.timeout(1e4),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        // DEC-1207: attribute this connector for the gateway's context.served seam. MCP is
+        // the dominant agent surface (INS-1706); without this header it was emitting nothing.
+        "x-pb-source": MCP_TELEMETRY_SOURCE
+      },
+      body: JSON.stringify({ fn, args })
+    });
+  } catch (err) {
+    audit(fn, "error", Date.now() - start, err.message);
+    throw new Error(`MCP call "${fn}" network error: ${err.message}`);
+  }
+  const json = await res.json();
+  if (!res.ok || json.ok === false) {
+    const errJson = json;
+    const msg = errJson.error ?? errJson.message ?? "unknown error";
+    audit(fn, "error", Date.now() - start, errJson.code ? `${msg} [${errJson.code}]` : msg);
+    throw new KernelCallError(
+      `MCP call "${fn}" failed (${res.status}): ${msg}`,
+      res.status,
+      errJson.code,
+      Array.isArray(errJson.missingRequiredFields) ? errJson.missingRequiredFields : void 0,
+      Array.isArray(errJson.fieldErrors) ? errJson.fieldErrors : void 0,
+      errJson.diagnostics && typeof errJson.diagnostics === "object" ? errJson.diagnostics : void 0
+    );
+  }
+  audit(fn, "ok", Date.now() - start);
+  const { data, summary, next, _meta } = json;
+  return {
+    data,
+    summary: summary || fn,
+    next,
+    _meta
+  };
+}
+async function kernelCall(fn, args = {}) {
+  const cached = getCached(fn, args);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const { data } = await callGateway(fn, args);
+  if (isWrite(fn)) {
+    invalidateReadCache();
+  } else {
+    setCached(fn, args, data);
+  }
+  const s = state();
+  if (s.agentSessionId && !TOUCH_EXCLUDED.has(fn)) {
+    touchSessionActivity();
+  }
+  return data;
+}
+async function kernelCallEnvelope(fn, args = {}) {
+  const { data, summary, next, _meta } = await callGateway(fn, args);
+  const s = state();
+  if (s.agentSessionId && !TOUCH_EXCLUDED.has(fn)) {
+    touchSessionActivity();
+  }
+  return { ok: true, summary, data, next, _meta };
+}
+var resolveInFlightMap = /* @__PURE__ */ new Map();
+async function getWorkspaceId() {
+  const s = state();
+  if (s.workspaceId) return s.workspaceId;
+  const apiKey = getActiveApiKey();
+  const existing = resolveInFlightMap.get(apiKey);
+  if (existing) return existing;
+  const promise = resolveWorkspaceWithRetry().finally(() => resolveInFlightMap.delete(apiKey));
+  resolveInFlightMap.set(apiKey, promise);
+  return promise;
+}
+async function resolveWorkspaceWithRetry(maxRetries = 2) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const workspace = await kernelCall("resolveWorkspace", {});
+      if (!workspace) {
+        throw new Error(
+          `API key is valid but no workspace is associated. Run \`npx ${MCP_NPX_PACKAGE} setup\` or regenerate your key.`
+        );
+      }
+      const s = state();
+      s.workspaceId = workspace._id;
+      s.workspaceSlug = workspace.slug;
+      s.workspaceName = workspace.name;
+      s.workspaceCreatedAt = workspace.createdAt ?? null;
+      s.workspaceGovernanceMode = workspace.governanceMode ?? "open";
+      if (workspace.keyScope) s.apiKeyScope = workspace.keyScope;
+      if (workspace.keyId) s.apiKeyId = workspace.keyId;
+      return s.workspaceId;
+    } catch (err) {
+      lastError = err;
+      const isTransient = /network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(err.message);
+      if (!isTransient || attempt === maxRetries) break;
+      const delay = 1e3 * (attempt + 1);
+      process.stderr.write(
+        `[MCP] Workspace resolution failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...
+`
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+async function getWorkspaceContext() {
+  const workspaceId = await getWorkspaceId();
+  const s = state();
+  return {
+    workspaceId,
+    workspaceSlug: s.workspaceSlug ?? "unknown",
+    workspaceName: s.workspaceName ?? "unknown",
+    createdAt: s.workspaceCreatedAt,
+    governanceMode: s.workspaceGovernanceMode ?? "open"
+  };
+}
+async function refreshWorkspaceGovernanceMode() {
+  const workspace = await kernelCall("resolveWorkspace", {});
+  const mode = workspace?.governanceMode ?? "open";
+  const s = state();
+  s.workspaceGovernanceMode = mode;
+  return mode;
+}
+async function kernelQuery(fn, args = {}) {
+  const workspaceId = await getWorkspaceId();
+  return kernelCall(fn, { ...args, workspaceId });
+}
+async function kernelMutation(fn, args = {}) {
+  const workspaceId = await getWorkspaceId();
+  return kernelCall(fn, { ...args, workspaceId });
+}
+function requireActiveSession() {
+  const s = state();
+  if (!s.agentSessionId) {
+    throw new Error(
+      "Active session required (SOS-iszqu7). Call `session action=start` then `orient` first."
+    );
+  }
+  if (s.sessionClosed) {
+    throw new Error(
+      "Session has been closed (SOS-iszqu7). Start a new session with `session action=start`."
+    );
+  }
+  if (!s.sessionOriented) {
+    throw new Error(
+      "Orientation required before accessing build context (SOS-iszqu7). Call `orient` first."
+    );
+  }
+}
+function requireWriteAccess() {
+  const s = state();
+  if (!s.agentSessionId) {
+    throw new Error(
+      "Agent session required for write operations. Call `session action=start` first."
+    );
+  }
+  if (s.sessionClosed) {
+    throw new Error(
+      "Agent session has been closed. Write tools are no longer available."
+    );
+  }
+  if (!s.sessionOriented) {
+    throw new Error(
+      "Orientation required before writing to the Chain. Call 'orient' first."
+    );
+  }
+  if (s.apiKeyScope === "read") {
+    throw new Error(
+      "This API key has read-only scope. Write tools are not available."
+    );
+  }
+}
+async function recoverSessionState() {
+  const s = state();
+  if (!s.workspaceId) return;
+  try {
+    const session = await kernelCall("agent.getActiveSession", { workspaceId: s.workspaceId });
+    if (session && session.status === "active") {
+      s.agentSessionId = session._id;
+      s.sessionOriented = session.oriented;
+      s.apiKeyScope = session.toolsScope;
+      s.sessionClosed = false;
+    }
+  } catch {
+  }
+}
+
+// src/prod-fallthrough.ts
+function warnOnProdFallthrough(resolved, opts) {
+  if (opts.explicit) return;
+  if (resolved.replace(/\/$/, "") !== DEFAULT_CLOUD_URL.replace(/\/$/, "")) return;
+  process.stderr.write(
+    `[MCP] No deployment URL configured \u2014 defaulting to the production gateway ${DEFAULT_CLOUD_URL}. Set CONVEX_SITE_URL or PRODUCTBRAIN_URL to target a different deployment.
+`
+  );
+}
+
+export {
+  initAnalytics,
+  trackSessionStarted,
+  trackSetupStarted,
+  trackSetupCompleted,
+  trackQualityVerdict,
+  trackQualityCheck,
+  trackCaptureClassifierEvaluated,
+  trackCaptureClassifierAutoRouted,
+  trackCaptureClassifierFallback,
+  trackChainEntryCommitted,
+  trackKnowledgeGap,
+  trackCaptureQualityHints,
+  trackCaptureRelationSuggestions,
+  trackCollectionClassified,
+  trackFieldGuidanceApplied,
+  trackFieldQualityWarning,
+  trackSessionCaptureRate,
+  trackZeroCaptureAuditFired,
+  trackCaptureContractMiss,
+  trackWriteBackHintServed,
+  trackCommitErrorByCode,
+  trackClassifierDivergence,
+  getPostHogClient,
+  shutdownAnalytics,
+  hashKey,
+  runWithAuth,
+  getRequestApiKey,
+  getKeyState,
+  MCP_NPX_PACKAGE,
+  resolveClient,
+  writeClientConfig,
+  warnOnProdFallthrough,
+  runWithToolContext,
+  DEFAULT_CLOUD_URL,
+  cacheScope,
+  getAgentSessionId,
+  isSessionOriented,
+  setSessionOriented,
+  getApiKeyScope,
+  startAgentSession,
+  closeAgentSession,
+  orphanAgentSession,
+  recordSessionActivity,
+  bootstrap,
+  bootstrapHttp,
+  getAuditLog,
+  kernelCall,
+  kernelCallEnvelope,
+  getWorkspaceId,
+  getWorkspaceContext,
+  refreshWorkspaceGovernanceMode,
+  kernelQuery,
+  kernelMutation,
+  requireActiveSession,
+  requireWriteAccess,
+  recoverSessionState
+};
+//# sourceMappingURL=chunk-6JNK5DIZ.js.map