@productbrain/mcp 0.0.1-beta.997 → 0.0.1-beta.9989

package/dist/chunk-XEKHBSS7.js

@@ -0,0 +1,1690 @@
+// 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 trackCompoundToolAction(tool, action, workspaceId) {
+  if (!client) return;
+  client.capture({
+    distinctId,
+    event: "mcp_compound_tool_action",
+    properties: {
+      tool,
+      action: action ?? null,
+      workspace_id: workspaceId,
+      source: "mcp-server",
+      $groups: { workspace: workspaceId }
+    }
+  });
+}
+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 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 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) {
+  if (!client) return;
+  try {
+    client.capture({
+      distinctId,
+      event: "zero_capture_audit_fired",
+      properties: {
+        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 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;
+}
+function getRequestMcpSessionId() {
+  return requestStore.getStore()?.mcpSessionId;
+}
+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,
+    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/generated/routeLatencyBudget.generated.ts
+var ROUTE_LATENCY_BUDGET_MS = {
+  query: 1e4,
+  mutation: 1e4,
+  action: 3e4
+};
+var ROUTE_LATENCY_BUDGET_OVERRIDE_MS = {
+  // convex/intelligence/onboardingChat.ts:333 declares `timeoutMs: 45_000` for the extraction
+  // LLM call — 15s BEYOND the flat action budget. 60s clears it with room for the surrounding
+  // request/response work the 45s covers none of.
+  "onboarding.chat": 6e4,
+  // convex/intelligence/spineCheck.ts:210 sets SPINE_CHECK_WALL_CLOCK_BUDGET_MS = 4 * 60_000
+  // for its SEQUENTIAL strategy probes (:225-239, deliberately not Promise.all), and :215
+  // reserves a tail of one 25s probe + an optional 25s story pass + 10s. The server's own
+  // design ceiling is scheduleSpineCheck's 5-min MAX_RUN_IN_FLIGHT_MS lease (:206-209).
+  // 5.5 min sits above that ceiling and far under Convex's 10-min action cap.
+  "quality.spineCheck": 33e4,
+  // convex/digest/compose.ts declares `timeoutMs: 120_000` (LLM_TIMEOUT_MS) for the digest
+  // composer's callOpenRouter call — but callOpenRouter's own MAX_RETRIES (=1,
+  // convex/lib/llm/openrouter.ts) means a transient-status (408/409/429/5xx) failure gets ONE
+  // retry of the FULL call, so the wrapper's genuine worst-case wall-clock is 2 attempts ×
+  // 120_000ms = 240_000ms, not a single attempt's timeout (PR #1122 round 1 review, P1 — the
+  // prior 150_000 sized for one attempt only). 270s clears the two-attempt worst case with
+  // room for the preceding cohort read (convex/digest/cohort.ts) and the surrounding
+  // request/response work neither the timeout nor the retry budget covers.
+  "chain.runDigest": 27e4
+};
+var WIDEST_ROUTE_LATENCY_BUDGET_MS = Math.max(
+  ...Object.values(ROUTE_LATENCY_BUDGET_MS),
+  ...Object.values(ROUTE_LATENCY_BUDGET_OVERRIDE_MS)
+);
+var ROUTE_TYPE_ENTRIES = {
+  "resolveWorkspace": "query",
+  "feedback.submit": "mutation",
+  "feedback.listOwn": "query",
+  "feedback.list": "action",
+  "feedback.note": "action",
+  "feedback.group": "action",
+  "feedback.status": "action",
+  "organisation.status": "query",
+  "organisation.removeMembership": "mutation",
+  "organisation.setOwnership": "mutation",
+  "organisation.hierarchy.show": "query",
+  "organisation.hierarchy.setParent": "mutation",
+  "organisation.hierarchy.clearParent": "mutation",
+  "acceptPolicy.approve": "mutation",
+  "acceptPolicy.retire": "mutation",
+  "acceptPolicy.list": "query",
+  "chain.seed": "mutation",
+  "chain.listCollections": "query",
+  "chain.getCollection": "query",
+  "chain.getCollectionFields": "query",
+  "chain.auditCollections": "query",
+  "chain.exportDefinitions": "query",
+  "chain.updateCollection": "mutation",
+  "chain.listEntries": "query",
+  "chain.listEntriesPaged": "query",
+  "chain.getEntry": "query",
+  "chain.preflightEntry": "query",
+  "chain.listByRole": "query",
+  "chain.getQualityVerdict": "query",
+  "chain.batchGetEntries": "query",
+  "chain.createEntry": "action",
+  "chain.updateEntry": "mutation",
+  "chain.restoreArchivedEntry": "mutation",
+  "chain.moveToCollection": "mutation",
+  "outcomes.recordReading": "mutation",
+  "outcomes.listReadings": "query",
+  "outcomes.showOutcome": "query",
+  "conflicts.list": "query",
+  "conflicts.resolve": "mutation",
+  "conflicts.summary": "query",
+  "conflicts.snooze": "mutation",
+  "conflicts.reverdict": "mutation",
+  "direction.list": "query",
+  "direction.refresh": "action",
+  "direction.defer": "mutation",
+  "question.create": "mutation",
+  "question.assign": "mutation",
+  "question.answer": "mutation",
+  "question.forceClose": "mutation",
+  "question.list": "query",
+  "chain.classifyCollection": "action",
+  "chain.classifyStrategyCategory": "query",
+  "chain.batchClassifyHeuristic": "query",
+  "chain.resolveCollection": "action",
+  "chain.searchEntries": "query",
+  "chain.searchByCanonicalName": "query",
+  "chain.commitEntry": "mutation",
+  "chain.verifyEntry": "mutation",
+  "chain.confirmEntry": "mutation",
+  "chain.tickChecklistItem": "mutation",
+  "chain.batchCommitConstellation": "mutation",
+  "chain.listEntryHistory": "query",
+  "chain.listEntryVersions": "query",
+  "chain.createEntryRelation": "mutation",
+  "chain.createEntryRelations": "mutation",
+  "chain.removeEntryRelation": "mutation",
+  "chain.normalizeEntryDataLLM": "action",
+  "chain.decomposeContent": "action",
+  "chain.normalizeEntryDataPreview": "action",
+  "chain.listEntryRelations": "query",
+  "chain.evaluateCoherence": "query",
+  "chain.validateCommitConstellation": "query",
+  "chain.getCaptureContract": "query",
+  "chain.gatherContext": "query",
+  "chain.getConstellation": "query",
+  "agentKnowledge.facilitateEnvelope": "action",
+  "agentKnowledge.wrapupEnvelope": "action",
+  "agentKnowledge.captureEnvelope": "action",
+  "chain.graphGatherContext": "query",
+  "chain.assembleBuildContext": "query",
+  "chain.qualityCheck": "query",
+  "chain.changeDetection": "query",
+  "chain.structuralAggregation": "query",
+  "chain.detectSemanticConflicts": "action",
+  "chain.taskAwareGatherContext": "query",
+  "chain.journeyAwareGatherContext": "query",
+  "chain.resolveTaskStartup": "query",
+  "chain.resolveTaskStartupHybrid": "action",
+  "chain.taskAwareHybridGatherContext": "action",
+  "chain.gatherFromSeeds": "query",
+  "chain.getEntryNeighborhood": "query",
+  "chain.deepChainWalk": "action",
+  "chain.recordBriefRun": "mutation",
+  "chain.getLastBriefRun": "query",
+  "chain.incrementalChanges": "query",
+  "chain.compoundQuery": "action",
+  "chain.recordSessionSignal": "mutation",
+  "chain.workspaceReadiness": "query",
+  "chain.getCaptureHealth": "query",
+  "chain.getGroundingHealth": "query",
+  "chain.recordGroundingOutcome": "mutation",
+  "chain.capture": "query",
+  "chain.runDigest": "action",
+  "chain.checkCardinalityWarning": "query",
+  "chain.ingestDocument": "action",
+  "chain.getOrientEntries": "query",
+  "chain.getOrientView": "action",
+  "chain.getRitualsSurface": "query",
+  "chain.getGovernanceWithRelations": "action",
+  "chain.classifyGovernance": "query",
+  "chain.getVocabulary": "query",
+  "scoreboard.get": "action",
+  "rework.report": "mutation",
+  "chain.listLabels": "query",
+  "chain.createLabel": "mutation",
+  "chain.updateLabel": "mutation",
+  "chain.deleteLabel": "mutation",
+  "chain.applyLabel": "mutation",
+  "chain.removeLabel": "mutation",
+  "chain.listEntriesByLabel": "query",
+  "gaps.record": "mutation",
+  "gaps.resolve": "mutation",
+  "gaps.top": "query",
+  "gaps.stats": "query",
+  "agent.startSession": "mutation",
+  "agent.resumeSession": "mutation",
+  "agent.closeSession": "mutation",
+  "agent.markOriented": "mutation",
+  "agent.touchSession": "mutation",
+  "agent.recordActivity": "mutation",
+  "agent.getSession": "query",
+  "agent.getActiveSession": "query",
+  "agent.activityStats": "query",
+  "agent.getActivityByDay": "query",
+  "agent.validateSession": "query",
+  "agent.getSessionWrapup": "query",
+  "agent.recordWrapup": "mutation",
+  "agent.reportOrientMetric": "mutation",
+  "agent.listSessions": "query",
+  "agent.showConversation": "query",
+  "usage.getWorkspaceSummary": "query",
+  "quality.evaluateHeuristicAndSchedule": "mutation",
+  "quality.reEvaluateEntry": "mutation",
+  "quality.evaluateAtCapture": "action",
+  "quality.evaluateAtCommit": "action",
+  "quality.evaluateForReview": "action",
+  "quality.getCachedVerdict": "query",
+  "quality.getLatestVerdictForEntry": "query",
+  "quality.spineCheck": "action",
+  "quality.scheduleSpineCheck": "mutation",
+  "quality.getLatestSpineVerdict": "query",
+  "onboarding.chat": "action",
+  "workspace.health": "query",
+  "workspace.healthAll": "query",
+  "performance.getVitalsSummary": "query",
+  "performance.getApiOverview": "query",
+  "performance.getRouteBreakdown": "query",
+  "performance.getSlowSamples": "query",
+  "performance.getSampleCount": "query",
+  "chainwork.getWorkflowRun": "query",
+  "chainwork.getLatestWorkflowRun": "query",
+  "chainwork.recordWorkflowCheckpoint": "mutation",
+  "chainwork.finalizeWorkflowRun": "action",
+  "chainwork.getLastVerifiedBrief": "query",
+  "staging.getCommittedSourceRefs": "query",
+  "staging.commitStagingEntryWithClassification": "action",
+  "organisation.seatInRole": "mutation",
+  "organisation.unseatFromRole": "mutation",
+  "apiKeys.revokeCallingKey": "mutation",
+  "people.invite": "mutation",
+  "people.list": "query"
+};
+var ROUTE_TYPE_BY_NAME = Object.assign(
+  /* @__PURE__ */ Object.create(null),
+  ROUTE_TYPE_ENTRIES
+);
+function latencyBudgetMsForRouteType(type) {
+  return ROUTE_LATENCY_BUDGET_MS[type];
+}
+function latencyBudgetMsForRoute(routeName) {
+  if (Object.hasOwn(ROUTE_LATENCY_BUDGET_OVERRIDE_MS, routeName)) {
+    return ROUTE_LATENCY_BUDGET_OVERRIDE_MS[routeName];
+  }
+  const type = ROUTE_TYPE_BY_NAME[routeName];
+  return type ? latencyBudgetMsForRouteType(type) : WIDEST_ROUTE_LATENCY_BUDGET_MS;
+}
+
+// src/lib/gatewaySeamStore.ts
+var AUDIT_BUFFER_SIZE = 50;
+var auditBufferByWorkspace = /* @__PURE__ */ new Map();
+var nextAuditSeq = 0;
+function getAuditLog(scopes) {
+  const merged = [];
+  for (const scope of new Set(scopes)) {
+    const bucket = auditBufferByWorkspace.get(scope);
+    if (bucket) merged.push(...bucket);
+  }
+  return merged.sort((a, b) => a.seq - b.seq);
+}
+function emptyByRoute() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function emptySeamCounters() {
+  return { calls: 0, errors: 0, timeouts: 0, totalDurationMs: 0, maxDurationMs: 0, byRoute: emptyByRoute() };
+}
+var MAX_SEAM_WORKSPACES = 200;
+var seamCountersByWorkspace = /* @__PURE__ */ new Map();
+function touchBoundedWorkspaceMap(map, workspace, create) {
+  const existing = map.get(workspace);
+  if (existing !== void 0) {
+    map.delete(workspace);
+    map.set(workspace, existing);
+    return existing;
+  }
+  if (map.size >= MAX_SEAM_WORKSPACES) {
+    const leastRecentlyRecorded = map.keys().next().value;
+    if (leastRecentlyRecorded !== void 0) map.delete(leastRecentlyRecorded);
+  }
+  const created = create();
+  map.set(workspace, created);
+  return created;
+}
+function getOrCreateWorkspaceCounters(workspace) {
+  return touchBoundedWorkspaceMap(seamCountersByWorkspace, workspace, emptySeamCounters);
+}
+function getOrCreateWorkspaceAuditBuffer(workspace) {
+  return touchBoundedWorkspaceMap(auditBufferByWorkspace, workspace, () => []);
+}
+function getGatewaySeamCounters(workspace) {
+  const counters = seamCountersByWorkspace.get(workspace);
+  if (!counters) return emptySeamCounters();
+  return {
+    calls: counters.calls,
+    errors: counters.errors,
+    timeouts: counters.timeouts,
+    totalDurationMs: counters.totalDurationMs,
+    maxDurationMs: counters.maxDurationMs,
+    // Copied onto a null prototype, not left as `Object.fromEntries`' plain object — the
+    // snapshot is indexed by route name downstream (`getMergedGatewaySeamCounters`) and would
+    // reintroduce the inherited-member collision `emptySeamCounters` documents.
+    byRoute: Object.assign(emptyByRoute(), Object.fromEntries(Object.entries(counters.byRoute).map(([k, v]) => [k, { ...v }])))
+  };
+}
+function getMergedGatewaySeamCounters(scopes) {
+  const merged = emptySeamCounters();
+  for (const scope of new Set(scopes)) {
+    const part = getGatewaySeamCounters(scope);
+    merged.calls += part.calls;
+    merged.errors += part.errors;
+    merged.timeouts += part.timeouts;
+    merged.totalDurationMs += part.totalDurationMs;
+    merged.maxDurationMs = Math.max(merged.maxDurationMs, part.maxDurationMs);
+    for (const [route, r] of Object.entries(part.byRoute)) {
+      const into = merged.byRoute[route] ??= { calls: 0, errors: 0, timeouts: 0, totalDurationMs: 0, maxDurationMs: 0 };
+      into.calls += r.calls;
+      into.errors += r.errors;
+      into.timeouts += r.timeouts;
+      into.totalDurationMs += r.totalDurationMs;
+      into.maxDurationMs = Math.max(into.maxDurationMs, r.maxDurationMs);
+    }
+  }
+  return merged;
+}
+function appendAuditEntry(entry) {
+  const stored = { ...entry, seq: nextAuditSeq++ };
+  const bucket = getOrCreateWorkspaceAuditBuffer(stored.workspace);
+  bucket.push(stored);
+  if (bucket.length > AUDIT_BUFFER_SIZE) bucket.shift();
+}
+function recordSeamCounters(workspace, fn, status, durationMs, timedOut) {
+  const seamCounters = getOrCreateWorkspaceCounters(workspace);
+  const route = seamCounters.byRoute[fn] ??= {
+    calls: 0,
+    errors: 0,
+    timeouts: 0,
+    totalDurationMs: 0,
+    maxDurationMs: 0
+  };
+  seamCounters.calls += 1;
+  seamCounters.totalDurationMs += durationMs;
+  if (durationMs > seamCounters.maxDurationMs) seamCounters.maxDurationMs = durationMs;
+  route.calls += 1;
+  route.totalDurationMs += durationMs;
+  if (durationMs > route.maxDurationMs) route.maxDurationMs = durationMs;
+  if (status === "error") {
+    seamCounters.errors += 1;
+    route.errors += 1;
+    if (timedOut) {
+      seamCounters.timeouts += 1;
+      route.timeouts += 1;
+    }
+  }
+}
+function formatGatewaySeamSummary(seam) {
+  const lines = [
+    "\n\n---\n\n# Gateway seam (process lifetime)\n",
+    `Calls: ${seam.calls} \u2014 errors: ${seam.errors}, of which timeouts: ${seam.timeouts}`
+  ];
+  if (seam.calls > 0) {
+    lines.push(`Mean: ${Math.round(seam.totalDurationMs / seam.calls)}ms \u2014 slowest: ${seam.maxDurationMs}ms`);
+  }
+  if (seam.timeouts > 0) {
+    lines.push(`\u26A0 ${seam.timeouts} call(s) hit their latency budget \u2014 those outcomes are unknown, not failed.`);
+  }
+  return lines.join("\n");
+}
+
+// src/gatewaySeam.ts
+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 GatewayTimeoutError = class extends Error {
+  /** Gateway route name that was aborted. */
+  fn;
+  /** The declared budget, in ms, that this route was given (see routeLatencyBudget). */
+  budgetMs;
+  /** Wall-clock ms actually spent before the abort. */
+  elapsedMs;
+  /**
+   * True when the aborted call could have landed a write server-side despite this client
+   * giving up. Derived by `mayHaveLandedOnTimeout` from the route contract's own function
+   * type (`mutation`/`action` mutate; `query` does not) AND the call's own arguments (a
+   * `preview: true` dry run writes nothing) — never guessed from the name.
+   */
+  mayHaveLanded;
+  constructor(fn, budgetMs, elapsedMs, mayHaveLanded) {
+    super(
+      `MCP call "${fn}" exceeded its ${budgetMs}ms latency budget (waited ${elapsedMs}ms).` + (mayHaveLanded ? " This route writes, so the server may have completed it \u2014 verify before retrying." : "")
+    );
+    this.name = "GatewayTimeoutError";
+    this.fn = fn;
+    this.budgetMs = budgetMs;
+    this.elapsedMs = elapsedMs;
+    this.mayHaveLanded = mayHaveLanded;
+  }
+};
+function routeMayMutate(fn) {
+  const type = ROUTE_TYPE_BY_NAME[fn];
+  return type === void 0 || type !== "query";
+}
+function isDryRunCall(args) {
+  return args?.preview === true;
+}
+function mayHaveLandedOnTimeout(fn, args) {
+  return routeMayMutate(fn) && !isDryRunCall(args);
+}
+function throwClassifiedGatewayFailure(err, fn, args, budgetMs, elapsedMs, phase, record) {
+  if (err?.name === "TimeoutError" || err?.name === "AbortError") {
+    const timeoutErr = new GatewayTimeoutError(fn, budgetMs, elapsedMs, mayHaveLandedOnTimeout(fn, args));
+    record(timeoutErr.message, true);
+    throw timeoutErr;
+  }
+  const detail = err?.message ?? String(err);
+  record(phase === "network" ? detail : `${phase}: ${detail}`, false);
+  throw new Error(`MCP call "${fn}" ${phase} error: ${detail}`);
+}
+function emptyBodyOrThrowClassified(err, fn, args, budgetMs, elapsedMs, statusOk, record) {
+  if (statusOk) throwClassifiedGatewayFailure(err, fn, args, budgetMs, elapsedMs, "response body", record);
+  return {};
+}
+function shouldLogAudit(status) {
+  return status === "error" || process.env.MCP_DEBUG === "1";
+}
+function recordGatewayCall(params) {
+  const { fn, status, durationMs, workspace, errorMsg, toolContext, budgetMs, timedOut } = params;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = { ts, fn, workspace, status, durationMs };
+  if (errorMsg) entry.error = errorMsg;
+  if (toolContext) entry.toolContext = toolContext;
+  if (budgetMs !== void 0) entry.budgetMs = budgetMs;
+  if (timedOut) entry.timedOut = true;
+  appendAuditEntry(entry);
+  recordSeamCounters(workspace, fn, status, durationMs, timedOut === true);
+  trackToolCall(fn, status, durationMs, workspace, errorMsg);
+  if (!shouldLogAudit(status)) return;
+  const base = `[MCP-AUDIT] ${ts} fn=${fn} workspace=${workspace} status=${status} duration=${durationMs}ms${budgetMs !== void 0 ? ` budget=${budgetMs}ms` : ""}${timedOut ? " timedOut=true" : ""}`;
+  process.stderr.write(
+    status === "error" && errorMsg ? `${base} error=${JSON.stringify(errorMsg)}
+` : `${base}
+`
+  );
+}
+
+// src/client.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+
+// src/errors.ts
+var MCP_CALL_ERROR_RE = /^MCP call "([^"]+)" failed \(\d+\): (.+)$/s;
+function asKernelCallError(err) {
+  if (!(err instanceof Error)) return void 0;
+  const e = err;
+  if (typeof e.code !== "string") return void 0;
+  const match = MCP_CALL_ERROR_RE.exec(e.message);
+  if (!match) return void 0;
+  return {
+    code: e.code,
+    fn: match[1],
+    cleanMessage: match[2],
+    // NOTE: match[2] not match[1] — group 1 is now fn scope (DEC-798)
+    missingRequiredFields: Array.isArray(e.missingRequiredFields) ? e.missingRequiredFields : void 0,
+    fieldErrors: Array.isArray(e.fieldErrors) ? e.fieldErrors : void 0
+  };
+}
+var GateError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GateError";
+  }
+};
+var BackendError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BackendError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var PASS_SESSION_ID = "Call `session action=start`, then pass the sessionId it returns as `sessionId` on every write: the connection does not remember your session between calls.";
+var GATE_PATTERNS = [
+  {
+    pattern: /session required|no active.*session|call.*session.*start/i,
+    code: "SESSION_REQUIRED",
+    recovery: PASS_SESSION_ID,
+    action: { tool: "session", description: "Start session", parameters: { action: "start" } }
+  },
+  {
+    pattern: /session.*closed/i,
+    code: "SESSION_CLOSED",
+    recovery: "Start a new session.",
+    action: { tool: "session", description: "Start new session", parameters: { action: "start" } }
+  },
+  {
+    pattern: /orientation required|call.*orient/i,
+    code: "ORIENTATION_REQUIRED",
+    recovery: "Run orient with a task, then retry.",
+    action: { tool: "orient", description: "Orient with a task", parameters: { action: "task" } }
+  },
+  {
+    pattern: /read.?only.*scope/i,
+    code: "READONLY_SCOPE",
+    recovery: "This API key cannot write. Use a readwrite key.",
+    action: { tool: "workspace", description: "Check key scope", parameters: { action: "whoami" } }
+  }
+];
+function orientationRefusal(err) {
+  const gate = GATE_PATTERNS.find((g) => g.code === "ORIENTATION_REQUIRED");
+  const mcpErr = asKernelCallError(err);
+  const message = mcpErr?.cleanMessage ?? (err instanceof Error ? err.message : String(err));
+  if (!gate || !gate.pattern.test(message)) return null;
+  return { code: gate.code, message, recovery: gate.recovery, availableActions: [gate.action] };
+}
+function classifyError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (err instanceof GateError) {
+    return {
+      code: "PERMISSION_DENIED",
+      message,
+      recovery: "Check permissions or use a readwrite API key.",
+      availableActions: [{ tool: "workspace", description: "Check key scope", parameters: { action: "whoami" } }]
+    };
+  }
+  if (err instanceof BackendError) {
+    return { code: "BACKEND_ERROR", message, recovery: "Retry the operation or check backend health." };
+  }
+  if (err instanceof ValidationError) {
+    return { code: "VALIDATION_ERROR", message };
+  }
+  const mcpErr = asKernelCallError(err);
+  if (mcpErr) {
+    const { code: convexCode, fn, cleanMessage, missingRequiredFields, fieldErrors } = mcpErr;
+    if (convexCode === "VALIDATION_FAILED") {
+      const hasDiagnostics = missingRequiredFields?.length || fieldErrors?.length;
+      return {
+        code: "VALIDATION_ERROR",
+        fn,
+        message: cleanMessage,
+        ...hasDiagnostics ? {
+          diagnostics: {
+            ...missingRequiredFields?.length ? { missingRequiredFields } : {},
+            ...fieldErrors?.length ? { fieldErrors } : {}
+          }
+        } : {}
+      };
+    }
+    if (convexCode === "NOT_FOUND") {
+      return {
+        code: "NOT_FOUND",
+        fn,
+        message: cleanMessage,
+        recovery: "Use context action=search to find the correct ID.",
+        availableActions: [{ tool: "context", description: "Search entries", parameters: { action: "search" } }]
+      };
+    }
+    if (convexCode?.startsWith("AUTHZ_")) {
+      return {
+        code: "PERMISSION_DENIED",
+        fn,
+        message: cleanMessage,
+        recovery: "Check permissions or use a readwrite API key.",
+        availableActions: [{ tool: "workspace", description: "Check key scope", parameters: { action: "whoami" } }]
+      };
+    }
+    if (convexCode === "WORKSPACE_SLUG_TAKEN" || convexCode === "PERSON_ALREADY_EXISTS") {
+      return {
+        code: "DUPLICATE",
+        fn,
+        message: cleanMessage,
+        recovery: "Use context action=get to inspect the existing entry.",
+        availableActions: [{ tool: "context", description: "Get entry", parameters: { action: "get" } }]
+      };
+    }
+    if (convexCode === "rate-limited") {
+      return {
+        code: "rate-limited",
+        fn,
+        message: cleanMessage,
+        recovery: "Rate limit hit for this API key. Wait the number of seconds in the message (Retry-After), then retry the same call unchanged \u2014 it is safe to retry."
+      };
+    }
+    return { code: convexCode, fn, message: cleanMessage };
+  }
+  for (const { pattern, code, recovery, action } of GATE_PATTERNS) {
+    if (pattern.test(message)) {
+      return { code, message, recovery, availableActions: [action] };
+    }
+  }
+  if (err?.name === "GatewayTimeoutError") {
+    const mayHaveLanded = err.mayHaveLanded === true;
+    return {
+      code: "GATEWAY_TIMEOUT",
+      message,
+      recovery: mayHaveLanded ? "The server was reachable and may have completed this write \u2014 verify before retrying, since a blind retry can duplicate it." : "The server was reachable but did not answer in time. Nothing was written \u2014 safe to retry."
+    };
+  }
+  if (/network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(message)) {
+    return { code: "BACKEND_UNAVAILABLE", message, recovery: "Retry in a few seconds." };
+  }
+  return { code: "INTERNAL_ERROR", message: message || "An unexpected error occurred." };
+}
+function retryIsFutile(code) {
+  return code === "VALIDATION_ERROR";
+}
+
+// src/lib/conversation.ts
+import { createHash as createHash2 } from "crypto";
+var MAX_RAW_LEN = 128;
+var SAFE_CHARS_RE = /^[A-Za-z0-9._-]+$/;
+function normalizeConversationId(raw) {
+  if (raw.length > MAX_RAW_LEN || !SAFE_CHARS_RE.test(raw)) {
+    return createHash2("sha256").update(raw).digest("hex");
+  }
+  return raw;
+}
+function pickRawConversationId() {
+  const candidates = [
+    process.env.PB_CONVERSATION_ID,
+    process.env.CLAUDE_CODE_SESSION_ID,
+    process.env.CURSOR_CONVERSATION_ID,
+    process.env.CODEX_TUI_SESSION_LOG_PATH
+  ];
+  for (const candidate of candidates) {
+    if (candidate && candidate.trim().length > 0) return candidate.trim();
+  }
+  return null;
+}
+function resolveConversationId() {
+  const raw = pickRawConversationId();
+  if (!raw) return null;
+  return normalizeConversationId(raw);
+}
+
+// src/lib/toolActionCounts.ts
+var toolActionCounts = /* @__PURE__ */ new Map();
+function actionCountKey(tool, action) {
+  return action ? `${tool}:${action}` : tool;
+}
+function recordToolAction(tool, action) {
+  const key = actionCountKey(tool, action);
+  toolActionCounts.set(key, (toolActionCounts.get(key) ?? 0) + 1);
+}
+
+// src/lib/deploymentUrlResolver.ts
+function parseFallbackUrls(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((u) => u.trim()).filter(Boolean);
+}
+async function checkKeyAgainstCandidates(candidates, apiKey, timeoutMs) {
+  let rejections = 0;
+  for (const url of candidates) {
+    let data;
+    try {
+      const res = await fetch(`${url}/api/key-check`, {
+        method: "POST",
+        headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) continue;
+      data = await res.json();
+    } catch {
+      continue;
+    }
+    if (data?.ok === true) {
+      return { verdict: "ok", url, deploymentUrl: data.deploymentUrl ?? url, workspaceName: data.workspaceName };
+    }
+    if (data?.ok === false && data.error === "rate_limited") {
+      return { verdict: "rate_limited", url, deploymentUrl: url, retryAfterSeconds: data.retryAfterSeconds };
+    }
+    if (data?.ok === false && data.error === "invalid_key") rejections++;
+  }
+  return candidates.length > 0 && rejections === candidates.length ? { verdict: "rejected" } : { verdict: "unreachable" };
+}
+async function probeDeploymentCandidates(candidates, apiKey) {
+  const result = await checkKeyAgainstCandidates(candidates, apiKey, 3e3);
+  return result.verdict === "ok" || result.verdict === "rate_limited" ? result.url : null;
+}
+
+// src/client.ts
+var _conversationId;
+function getConversationId() {
+  const mcpSid = getRequestMcpSessionId();
+  if (mcpSid) return sessionLifecycle().conversationId ?? `mcp:${mcpSid}`;
+  if (getRequestApiKey()) return null;
+  if (_conversationId === void 0) _conversationId = resolveConversationId();
+  return _conversationId;
+}
+var toolContextStore = new AsyncLocalStorage2();
+function runWithToolContext(ctx, fn) {
+  recordToolAction(ctx.tool, ctx.action);
+  trackCompoundToolAction(ctx.tool, ctx.action, state().workspaceId ?? "unresolved");
+  return toolContextStore.run(ctx, fn);
+}
+function getToolContext() {
+  return toolContextStore.getStore() ?? null;
+}
+var DEFAULT_CLOUD_URL = "https://gateway.productbrain.io";
+var CACHE_TTL_MS = 6e4;
+var CACHEABLE_FNS = [
+  "chain.gatherContext",
+  "chain.graphGatherContext",
+  "chain.journeyAwareGatherContext",
+  "chain.assembleBuildContext"
+];
+function isCacheable(fn) {
+  return CACHEABLE_FNS.includes(fn);
+}
+function invalidatesReadCache(fn) {
+  return routeMayMutate(fn) && !TOUCH_EXCLUDED.has(fn);
+}
+var readCache = /* @__PURE__ */ new Map();
+function cacheKey(fn, args) {
+  return `${cacheScope()}:${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,
+  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;
+}
+var _sessionLifecycleByStream = /* @__PURE__ */ new Map();
+var MAX_SESSION_STREAMS = 500;
+function sessionLifecycle() {
+  const seated = seatedSessionStore.getStore();
+  if (seated) return seated;
+  const mcpSid = getRequestMcpSessionId();
+  if (!mcpSid) return state();
+  const key = `${cacheScope()}:${mcpSid}`;
+  let lc = _sessionLifecycleByStream.get(key);
+  if (!lc) {
+    if (_sessionLifecycleByStream.size >= MAX_SESSION_STREAMS) {
+      const oldest = _sessionLifecycleByStream.keys().next().value;
+      if (oldest !== void 0) _sessionLifecycleByStream.delete(oldest);
+    }
+    lc = { agentSessionId: null, sessionOriented: false, sessionClosed: false };
+    _sessionLifecycleByStream.set(key, lc);
+  }
+  return lc;
+}
+function getAgentSessionId() {
+  return sessionLifecycle().agentSessionId;
+}
+function isSessionOriented() {
+  return sessionLifecycle().sessionOriented;
+}
+function setSessionOriented(value) {
+  sessionLifecycle().sessionOriented = value;
+}
+function getApiKeyScope() {
+  return state().apiKeyScope;
+}
+var seatedSessionStore = new AsyncLocalStorage2();
+var getApiKeyId = () => state().apiKeyId;
+var runWithSeatedSession = (lc, fn) => seatedSessionStore.run(lc, fn);
+var forgetStreamLifecycle = (keyHash, mcpSessionId) => _sessionLifecycleByStream.delete(`${keyHash}:${mcpSessionId}`);
+async function startAgentSession(role) {
+  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",
+    // WP-479 E2: resolved once at process startup and held — see getConversationId() above.
+    conversationId: getConversationId() ?? void 0,
+    role
+  });
+  const lc = sessionLifecycle();
+  if (lc.agentSessionId) resetTouchThrottle(lc.agentSessionId);
+  lc.agentSessionId = result.sessionId;
+  s.apiKeyScope = result.toolsScope;
+  lc.sessionOriented = false;
+  lc.sessionClosed = false;
+  resetTouchThrottle(result.sessionId);
+  return result;
+}
+async function closeAgentSession() {
+  const lc = sessionLifecycle();
+  if (!lc.agentSessionId) return;
+  const sessionId = lc.agentSessionId;
+  try {
+    await kernelCall("agent.closeSession", {
+      sessionId,
+      status: "closed"
+    });
+  } finally {
+    resetTouchThrottle(sessionId);
+    lc.sessionClosed = true;
+    lc.agentSessionId = null;
+    lc.sessionOriented = false;
+  }
+}
+async function orphanAgentSession() {
+  const lc = sessionLifecycle();
+  if (!lc.agentSessionId) return;
+  const sessionId = lc.agentSessionId;
+  try {
+    await kernelCall("agent.closeSession", {
+      sessionId,
+      status: "orphaned"
+    });
+  } catch {
+  } finally {
+    resetTouchThrottle(sessionId);
+    lc.agentSessionId = null;
+    lc.sessionOriented = false;
+  }
+}
+var _lastTouchAtBySession = /* @__PURE__ */ new Map();
+var TOUCH_THROTTLE_MS = 5e3;
+function touchSessionActivity() {
+  const sessionId = sessionLifecycle().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 sessionId = sessionLifecycle().agentSessionId;
+  if (!sessionId) return;
+  try {
+    await kernelCall("agent.recordActivity", {
+      sessionId,
+      ...activity
+    });
+  } catch {
+  }
+}
+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 });
+}
+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(process.env.CONVEX_FALLBACK_URLS);
+  if (fallbacks.length === 0) {
+    return primaryUrl;
+  }
+  const candidates = [primaryUrl, ...fallbacks.map((u) => u.replace(/\/$/, ""))];
+  let apiKey;
+  try {
+    apiKey = getActiveApiKey();
+  } catch {
+    return primaryUrl;
+  }
+  const found = await probeDeploymentCandidates(candidates, apiKey);
+  if (found) {
+    s.deploymentUrl = found;
+    return found;
+  }
+  return candidates[0];
+}
+function audit(fn, status, durationMs, errorMsg, meta) {
+  recordGatewayCall({
+    fn,
+    status,
+    durationMs,
+    errorMsg,
+    workspace: state().workspaceId ?? cacheScope(),
+    toolContext: getToolContext(),
+    budgetMs: meta?.budgetMs,
+    timedOut: meta?.timedOut
+  });
+}
+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 budgetMs = latencyBudgetMsForRoute(fn);
+  const start = Date.now();
+  let res;
+  try {
+    res = await fetch(`${siteUrl}/api/aki`, {
+      method: "POST",
+      signal: AbortSignal.timeout(budgetMs),
+      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) {
+    throwClassifiedGatewayFailure(
+      err,
+      fn,
+      args,
+      budgetMs,
+      Date.now() - start,
+      "network",
+      (m, t) => audit(fn, "error", Date.now() - start, m, { budgetMs, timedOut: t })
+    );
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch (err) {
+    json = emptyBodyOrThrowClassified(
+      err,
+      fn,
+      args,
+      budgetMs,
+      Date.now() - start,
+      res.ok,
+      (m, t) => audit(fn, "error", Date.now() - start, m, { budgetMs, timedOut: t })
+    );
+  }
+  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, { budgetMs });
+    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, void 0, { budgetMs });
+  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 (invalidatesReadCache(fn)) {
+    invalidateReadCache();
+  } else {
+    setCached(fn, args, data);
+  }
+  if (getAgentSessionId() && !TOUCH_EXCLUDED.has(fn)) {
+    touchSessionActivity();
+  }
+  return data;
+}
+async function kernelCallEnvelope(fn, args = {}) {
+  const { data, summary, next, _meta } = await callGateway(fn, args);
+  if (getAgentSessionId() && !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;
+      if (workspace.keyScope) s.apiKeyScope = workspace.keyScope;
+      if (workspace.keyId) s.apiKeyId = workspace.keyId;
+      return s.workspaceId;
+    } catch (err) {
+      lastError = err;
+      const isTransient = err?.name === "GatewayTimeoutError" || /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
+  };
+}
+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 lc = sessionLifecycle();
+  if (!lc.agentSessionId) {
+    throw new Error(
+      "Active session required (SOS-iszqu7). Call `session action=start` then `orient` first."
+    );
+  }
+  if (lc.sessionClosed) {
+    throw new Error(
+      "Session has been closed (SOS-iszqu7). Start a new session with `session action=start`."
+    );
+  }
+}
+function requireWriteAccess() {
+  const lc = sessionLifecycle();
+  const s = state();
+  if (!lc.agentSessionId) {
+    throw new Error(`Agent session required for write operations. ${PASS_SESSION_ID}`);
+  }
+  if (lc.sessionClosed) {
+    throw new Error(
+      "Agent session has been closed. Write tools are no longer available."
+    );
+  }
+  if (s.apiKeyScope === "read") {
+    throw new Error(
+      "This API key has read-only scope. Write tools are not available."
+    );
+  }
+}
+function requireVendorTriageAccess() {
+  const lc = sessionLifecycle();
+  const s = state();
+  if (!lc.agentSessionId) {
+    throw new Error(
+      "Agent session required for feedback triage. Call `session action=start` first."
+    );
+  }
+  if (lc.sessionClosed) {
+    throw new Error(
+      "Agent session has been closed. Feedback triage is no longer available."
+    );
+  }
+  if (s.apiKeyScope === "read") {
+    throw new Error(
+      "This API key has read-only scope. Feedback triage is not available."
+    );
+  }
+}
+async function recoverSessionState() {
+  const s = state();
+  if (!s.workspaceId) return;
+  try {
+    const session = await kernelCall("agent.getActiveSession", {
+      workspaceId: s.workspaceId,
+      // WP-479 E2: required disambiguation arg for the per-apiKey-quota re-scoped
+      // getActiveSession — absent identity (null) still resolves to the keyless/legacy path
+      // server-side.
+      conversationId: getConversationId() ?? void 0
+    });
+    if (session && session.status === "active") {
+      const lc = sessionLifecycle();
+      lc.agentSessionId = session._id;
+      lc.sessionOriented = session.oriented;
+      s.apiKeyScope = session.toolsScope;
+      lc.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.
+`
+  );
+}
+
+// src/lib/appUrl.ts
+function appUrl() {
+  return (process.env.PRODUCTBRAIN_APP_URL ?? "https://work.productbrain.io").replace(/\/$/, "");
+}
+function apiKeysUrl() {
+  return `${appUrl()}/settings/api-keys`;
+}
+
+export {
+  initAnalytics,
+  trackSessionStarted,
+  trackSetupStarted,
+  trackSetupCompleted,
+  trackQualityVerdict,
+  trackQualityCheck,
+  trackCaptureClassifierEvaluated,
+  trackCaptureClassifierAutoRouted,
+  trackCaptureClassifierFallback,
+  trackChainEntryCommitted,
+  trackKnowledgeGap,
+  trackCaptureQualityHints,
+  trackCollectionClassified,
+  trackSessionCaptureRate,
+  trackZeroCaptureAuditFired,
+  trackCaptureContractMiss,
+  trackCommitErrorByCode,
+  trackClassifierDivergence,
+  getPostHogClient,
+  shutdownAnalytics,
+  getAuditLog,
+  getMergedGatewaySeamCounters,
+  formatGatewaySeamSummary,
+  KernelCallError,
+  hashKey,
+  runWithAuth,
+  getKeyState,
+  MCP_NPX_PACKAGE,
+  resolveClient,
+  writeClientConfig,
+  PASS_SESSION_ID,
+  orientationRefusal,
+  classifyError,
+  retryIsFutile,
+  warnOnProdFallthrough,
+  parseFallbackUrls,
+  checkKeyAgainstCandidates,
+  getConversationId,
+  runWithToolContext,
+  DEFAULT_CLOUD_URL,
+  cacheScope,
+  getAgentSessionId,
+  isSessionOriented,
+  setSessionOriented,
+  getApiKeyScope,
+  getApiKeyId,
+  runWithSeatedSession,
+  forgetStreamLifecycle,
+  startAgentSession,
+  closeAgentSession,
+  orphanAgentSession,
+  recordSessionActivity,
+  bootstrap,
+  bootstrapHttp,
+  kernelCall,
+  kernelCallEnvelope,
+  getWorkspaceId,
+  getWorkspaceContext,
+  kernelQuery,
+  kernelMutation,
+  requireActiveSession,
+  requireWriteAccess,
+  requireVendorTriageAccess,
+  recoverSessionState,
+  appUrl,
+  apiKeysUrl
+};
+//# sourceMappingURL=chunk-XEKHBSS7.js.map