@productbrain/mcp 0.0.1-beta.3503 → 0.0.1-beta.3516

package/dist/{chunk-U7YKAA66.js → chunk-VCTFH2U7.js}

@@ -505,6 +505,515 @@ async function writeClientConfig(client2, apiKey) {
   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
+};
+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.assignMembership": "mutation",
+  "organisation.removeMembership": "mutation",
+  "organisation.setOwnership": "mutation",
+  "organisation.clearOwnership": "mutation",
+  "organisation.activate": "mutation",
+  "organisation.upgrade": "mutation",
+  "organisation.upgradeRung2": "mutation",
+  "organisation.upgradeRung3": "mutation",
+  "organisation.upgradeRung4": "mutation",
+  "organisation.updateGovernanceMode": "mutation",
+  "organisation.hierarchy.show": "query",
+  "organisation.hierarchy.setParent": "mutation",
+  "organisation.hierarchy.clearParent": "mutation",
+  "chain.seed": "mutation",
+  "chain.listCollections": "query",
+  "chain.getCollection": "query",
+  "chain.getCollectionFields": "query",
+  "chain.auditCollections": "query",
+  "chain.exportDefinitions": "query",
+  "chain.createCollection": "mutation",
+  "chain.updateCollection": "mutation",
+  "chain.listEntries": "query",
+  "chain.getEntry": "query",
+  "chain.batchGetEntries": "query",
+  "chain.createEntry": "action",
+  "chain.updateEntry": "mutation",
+  "chain.restoreArchivedEntry": "mutation",
+  "chain.moveToCollection": "mutation",
+  "chain.shapeAdvisories": "query",
+  "chain.shapeAdvisorySummary": "query",
+  "chain.showShapeAdvisory": "query",
+  "chain.dispositionShapeAdvisory": "mutation",
+  "conflicts.list": "query",
+  "conflicts.resolve": "mutation",
+  "conflicts.summary": "query",
+  "conflicts.snooze": "mutation",
+  "conflicts.reverdict": "mutation",
+  "direction.list": "query",
+  "direction.refresh": "action",
+  "direction.defer": "mutation",
+  "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.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.scoreLinkCandidates": "query",
+  "chain.evaluateCoherence": "query",
+  "chain.listAutoLinkSuggestions": "query",
+  "chain.acceptAutoLinkSuggestion": "mutation",
+  "chain.dismissAutoLinkSuggestion": "mutation",
+  "chain.quarantineAutoLinkSuggestion": "mutation",
+  "chain.resurrectAutoLinkSuggestion": "mutation",
+  "chain.expireAutoLinkSuggestion": "mutation",
+  "chain.clusterAutoLinkSuggestions": "query",
+  "chain.batchApplyAutoLinkSuggestions": "action",
+  "chain.validateCommitConstellation": "query",
+  "chain.getCaptureContract": "query",
+  "chain.gatherContext": "query",
+  "chain.getConstellation": "query",
+  "chain.auditBet": "query",
+  "agentKnowledge.facilitateEnvelope": "action",
+  "agentKnowledge.wrapupEnvelope": "action",
+  "agentKnowledge.captureEnvelope": "action",
+  "chain.graphSuggestLinks": "query",
+  "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.getBindingGovernanceView": "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.dismissSuggestion": "mutation",
+  "chain.recordSessionSignal": "mutation",
+  "chain.workspaceReadiness": "query",
+  "chain.getCaptureHealth": "query",
+  "chain.getGroundingHealth": "query",
+  "chain.recordGroundingOutcome": "mutation",
+  "chain.suggestLinksForCapture": "query",
+  "chain.setOnboardingCompleted": "mutation",
+  "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",
+  "setup.getActiveSurface": "query",
+  "setup.materializeSetup": "action",
+  "setup.recordTamperRefusal": "mutation",
+  "setup.recordTransition": "mutation",
+  "setup.getCurrentSetupState": "query",
+  "setup.listAssetsForUser": "query",
+  "setup.ingestSetupAsset": "mutation",
+  "setup.ingestSetupAssetWithBody": "action",
+  "setup.fetchAssetBody": "action",
+  "setup.auditAssetBodies": "action",
+  "setup.repairAssetBody": "action",
+  "setup.listFailedAuditReceipts": "action",
+  "setup.markPersonalSetupAssetDormantFromSync": "mutation",
+  "setup.resolveSemanticRefs": "query",
+  "setup.updateLastProjectedHash": "mutation",
+  "setup.getSkillSystemHealth": "query",
+  "setup.recordActivationReceipt": "mutation",
+  "setup.recordSetupInvocation": "mutation",
+  "setup.getUserActivationState": "query",
+  "setup.getPbSetupState": "query",
+  "setup.getSkillBody": "action",
+  "setup.stampMcpOnlySurface": "mutation",
+  "setup.stampDetectedSurfaces": "mutation",
+  "setup.getKey32Snapshot": "query",
+  "setup.getKey33Snapshot": "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.recentSessions": "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",
+  "workspace.backfill": "mutation",
+  "workspace.backfillAll": "mutation",
+  "authorityDomains.readiness": "query",
+  "authorityDomains.add": "mutation",
+  "authorityDomains.propose": "action",
+  "authorityDomains.review": "query",
+  "authorityDomains.queueKnownTag": "mutation",
+  "authorityDomains.ratify": "mutation",
+  "authorityDomains.reject": "mutation",
+  "authorityDomains.discardPending": "mutation",
+  "authorityDomains.recordSample": "mutation",
+  "authorityDomains.benchmark": "action",
+  "authorityDomains.activateCutover": "mutation",
+  "authorityDomains.principleDistribution": "query",
+  "performance.getVitalsSummary": "query",
+  "performance.getApiOverview": "query",
+  "performance.getRouteBreakdown": "query",
+  "performance.getSlowSamples": "query",
+  "performance.getSampleCount": "query",
+  "chainwork.listTypes": "query",
+  "chainwork.getChainType": "query",
+  "chainwork.scoreRun": "query",
+  "chainwork.getArtifact": "query",
+  "chainwork.getWorkflowRun": "query",
+  "chainwork.getLatestWorkflowRun": "query",
+  "chainwork.recordWorkflowCheckpoint": "mutation",
+  "chainwork.finalizeWorkflowRun": "action",
+  "chainwork.submitToKG": "action",
+  "chainwork.generate": "action",
+  "chainwork.getLastVerifiedBrief": "query",
+  "gitchain.createChain": "mutation",
+  "gitchain.editLink": "mutation",
+  "gitchain.updateChain": "mutation",
+  "gitchain.getChain": "query",
+  "gitchain.listChains": "query",
+  "gitchain.getHistory": "query",
+  "gitchain.listCommits": "query",
+  "gitchain.commitChain": "mutation",
+  "gitchain.diffVersions": "mutation",
+  "gitchain.runGate": "query",
+  "gitchain.createBranch": "mutation",
+  "gitchain.listBranches": "mutation",
+  "gitchain.checkConflicts": "mutation",
+  "gitchain.mergeBranch": "mutation",
+  "gitchain.addComment": "mutation",
+  "gitchain.resolveComment": "mutation",
+  "gitchain.listComments": "mutation",
+  "gitchain.revertChain": "mutation",
+  "staging.getCommittedSourceRefs": "query",
+  "staging.commitStagingEntryWithClassification": "action",
+  "governance.listProposals": "query",
+  "governance.countOpenProposals": "query",
+  "governance.respondToProposal": "mutation",
+  "maps.createMap": "mutation",
+  "maps.createAudienceMapSet": "mutation",
+  "maps.addToSlot": "mutation",
+  "maps.removeFromSlot": "mutation",
+  "maps.replaceInSlot": "mutation",
+  "maps.commitMap": "mutation",
+  "maps.getMap": "query",
+  "maps.listMaps": "query",
+  "maps.getJourneyMapWithEnrichment": "query",
+  "maps.listJourneyMaps": "query",
+  "maps.listMapCommits": "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";
 
@@ -546,6 +1055,29 @@ function recordToolAction(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 probeDeploymentCandidates(candidates, apiKey) {
+  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) return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
 // src/client.ts
 var _conversationId;
 function getConversationId() {
@@ -565,30 +1097,6 @@ 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",
@@ -775,8 +1283,6 @@ async function recordSessionActivity(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;
@@ -793,16 +1299,11 @@ function bootstrapHttp() {
   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();
+  const fallbacks = parseFallbackUrls(process.env.CONVEX_FALLBACK_URLS);
   if (fallbacks.length === 0) {
     return primaryUrl;
   }
@@ -813,50 +1314,24 @@ async function resolveDeploymentUrl() {
   } 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 {
-    }
+  const found = await probeDeploymentCandidates(candidates, apiKey);
+  if (found) {
+    s.deploymentUrl = found;
+    return found;
   }
   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;
+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",
@@ -874,12 +1349,13 @@ 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(1e4),
+      signal: AbortSignal.timeout(budgetMs),
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${apiKey}`,
@@ -890,14 +1366,34 @@ async function callGateway(fn, args) {
       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}`);
+    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 })
+    );
   }
-  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);
+    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,
@@ -907,7 +1403,7 @@ async function callGateway(fn, args) {
       errJson.diagnostics && typeof errJson.diagnostics === "object" ? errJson.diagnostics : void 0
     );
   }
-  audit(fn, "ok", Date.now() - start);
+  audit(fn, "ok", Date.now() - start, void 0, { budgetMs });
   const { data, summary, next, _meta } = json;
   return {
     data,
@@ -971,7 +1467,7 @@ async function resolveWorkspaceWithRetry(maxRetries = 2) {
       return s.workspaceId;
     } catch (err) {
       lastError = err;
-      const isTransient = /network error|fetch failed|ECONNREFUSED|ETIMEDOUT/i.test(err.message);
+      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(
@@ -1127,6 +1623,10 @@ export {
   trackClassifierDivergence,
   getPostHogClient,
   shutdownAnalytics,
+  getAuditLog,
+  getMergedGatewaySeamCounters,
+  formatGatewaySeamSummary,
+  KernelCallError,
   hashKey,
   runWithAuth,
   getRequestApiKey,
@@ -1138,7 +1638,6 @@ export {
   getConversationId,
   runWithToolContext,
   DEFAULT_CLOUD_URL,
-  KernelCallError,
   cacheScope,
   getAgentSessionId,
   isSessionOriented,
@@ -1150,7 +1649,6 @@ export {
   recordSessionActivity,
   bootstrap,
   bootstrapHttp,
-  getAuditLog,
   kernelCall,
   kernelCallEnvelope,
   getWorkspaceId,
@@ -1163,4 +1661,4 @@ export {
   requireVendorTriageAccess,
   recoverSessionState
 };
-//# sourceMappingURL=chunk-U7YKAA66.js.map
+//# sourceMappingURL=chunk-VCTFH2U7.js.map