@lucern/sdk 0.3.0-alpha.2 → 0.3.0-alpha.3

package/dist/client.js

@@ -1,4 +1,171 @@
 import { z } from 'zod';
+import { MCP_GATEWAY_EVALUATE_RESEARCH_CONTRACT_ENDPOINT, MCP_GATEWAY_EVALUATE_ENGINEERING_CONTRACT_ENDPOINT, MCP_GATEWAY_BEGIN_BUILD_SESSION_ENDPOINT, MCP_GATEWAY_WRITE_POLICY_CHECK_ENDPOINT, MCP_GATEWAY_BOOTSTRAP_ENDPOINT } from '@lucern/contracts/mcp-gateway-boundary.contract';
+
+// src/authContext.ts
+var LucernSdkAuthContextError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "LucernSdkAuthContextError";
+    this.reason = reason;
+  }
+};
+function cleanString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function cleanStringList(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((value) => value.trim()).filter(
+    (value, index, list) => value.length > 0 && list.indexOf(value) === index
+  );
+}
+function requireString(value, reason, label) {
+  const normalized = cleanString(value);
+  if (!normalized) {
+    throw new LucernSdkAuthContextError(
+      reason,
+      `Canonical Lucern SDK auth context is missing ${label}.`
+    );
+  }
+  return normalized;
+}
+function requirePrincipalType(principalType) {
+  if (!principalType) {
+    throw new LucernSdkAuthContextError(
+      "principal_missing",
+      "Canonical Lucern SDK auth context is missing principalType."
+    );
+  }
+  return principalType;
+}
+function requireAuthMode(authMode) {
+  if (!authMode) {
+    throw new LucernSdkAuthContextError(
+      "principal_missing",
+      "Canonical Lucern SDK auth context is missing authMode."
+    );
+  }
+  return authMode;
+}
+function ensurePermitMatch(args) {
+  const actual = cleanString(args.actual);
+  if (actual && actual !== args.expected) {
+    throw new LucernSdkAuthContextError(
+      "policy_denied",
+      `Canonical Lucern SDK auth context has conflicting Permit ${args.field}.`
+    );
+  }
+}
+function normalizeCanonicalLucernAuthContext(input) {
+  if (!input) {
+    throw new LucernSdkAuthContextError(
+      "principal_missing",
+      "Canonical Lucern SDK auth context is required."
+    );
+  }
+  if (input.policyDecision === "deny") {
+    throw new LucernSdkAuthContextError(
+      "policy_denied",
+      "Canonical Lucern SDK auth context carries a denied policy decision."
+    );
+  }
+  const principalId = requireString(
+    input.principalId,
+    "principal_missing",
+    "principalId"
+  );
+  const tenantId = requireString(input.tenantId, "tenant_missing", "tenantId");
+  const workspaceId = requireString(
+    input.workspaceId,
+    "workspace_missing",
+    "workspaceId"
+  );
+  const roles = cleanStringList(input.roles);
+  const scopes = cleanStringList(input.scopes);
+  if (roles.length === 0 || scopes.length === 0) {
+    throw new LucernSdkAuthContextError(
+      "membership_missing",
+      "Canonical Lucern SDK auth context requires non-empty roles and scopes."
+    );
+  }
+  const principalType = requirePrincipalType(input.principalType);
+  const authMode = requireAuthMode(input.authMode);
+  const subject = cleanString(input.permit?.subject) ?? principalId;
+  const tenant = cleanString(input.permit?.tenant) ?? tenantId;
+  const workspace = cleanString(input.permit?.workspace) ?? workspaceId;
+  ensurePermitMatch({
+    field: "subject",
+    expected: principalId,
+    actual: subject
+  });
+  ensurePermitMatch({ field: "tenant", expected: tenantId, actual: tenant });
+  ensurePermitMatch({
+    field: "workspace",
+    expected: workspaceId,
+    actual: workspace
+  });
+  const context = input.permit?.context ? { ...input.permit.context } : void 0;
+  return {
+    clerkId: cleanString(input.clerkId),
+    principalId,
+    tenantId,
+    workspaceId,
+    principalType,
+    authMode,
+    roles,
+    scopes,
+    delegationChain: input.delegationChain ? [...input.delegationChain] : [],
+    policyTraceId: cleanString(input.policyTraceId),
+    correlationId: cleanString(input.correlationId),
+    membershipId: cleanString(input.membershipId),
+    permit: {
+      subject,
+      tenant,
+      workspace,
+      resource: cleanString(input.permit?.resource),
+      action: cleanString(input.permit?.action),
+      relation: cleanString(input.permit?.relation),
+      context
+    }
+  };
+}
+function createCanonicalAuthHeaders(authContext) {
+  const headers = {
+    "x-lucern-principal-id": authContext.principalId,
+    "x-lucern-principal-type": authContext.principalType,
+    "x-lucern-tenant": authContext.tenantId,
+    "x-lucern-tenant-id": authContext.tenantId,
+    "x-lucern-workspace": authContext.workspaceId,
+    "x-lucern-workspace-id": authContext.workspaceId,
+    "x-lucern-auth-mode": authContext.authMode,
+    "x-lucern-roles": authContext.roles.join(","),
+    "x-lucern-scopes": authContext.scopes.join(","),
+    "x-lucern-permit-context": JSON.stringify(authContext.permit)
+  };
+  if (authContext.clerkId) {
+    headers["x-lucern-clerk-id"] = authContext.clerkId;
+    headers["x-lucern-user-id"] = authContext.clerkId;
+  }
+  if (authContext.delegationChain.length > 0) {
+    headers["x-lucern-delegation-chain"] = JSON.stringify(
+      authContext.delegationChain
+    );
+  }
+  if (authContext.policyTraceId) {
+    headers["x-lucern-policy-trace-id"] = authContext.policyTraceId;
+  }
+  if (authContext.correlationId) {
+    headers["x-correlation-id"] = authContext.correlationId;
+    headers["x-lucern-correlation-id"] = authContext.correlationId;
+  }
+  if (authContext.membershipId) {
+    headers["x-lucern-membership-id"] = authContext.membershipId;
+  }
+  return headers;
+}
 
 // src/coreClient.ts
 var LucernApiError = class extends Error {
@@ -156,16 +323,41 @@ function readPolicySummaryFromDetails(details) {
   }
   return null;
 }
+async function resolveConfiguredAuthContext(authContext) {
+  if (typeof authContext === "function") {
+    return await authContext();
+  }
+  return authContext;
+}
+function mergeHeaderRecord(base, addition) {
+  const headers = new Headers(base);
+  for (const [key, value] of Object.entries(addition)) {
+    const existing = headers.get(key);
+    if (existing !== null && existing !== value) {
+      throw new LucernSdkAuthContextError(
+        "policy_denied",
+        `Canonical Lucern SDK auth context conflicts with existing ${key} header.`
+      );
+    }
+    headers.set(key, value);
+  }
+  return Object.fromEntries(headers.entries());
+}
 function createGatewayRequestClient(config = {}) {
   const fetchImpl = config.fetchImpl ?? fetch;
   const baseUrl = config.baseUrl?.replace(/\/+$/, "") ?? "";
   const maxRetries = config.maxRetries ?? 2;
   const requestIdFactory = config.requestIdFactory ?? (() => generatePortableRequestId());
   async function resolveAuthHeaders() {
-    if (!config.getAuthHeaders) {
-      return {};
+    const base = config.getAuthHeaders ? await config.getAuthHeaders() : {};
+    const authContextInput = await resolveConfiguredAuthContext(
+      config.authContext
+    );
+    if (!authContextInput && !config.requireCanonicalAuthContext) {
+      return base;
     }
-    return await config.getAuthHeaders();
+    const authContext = normalizeCanonicalLucernAuthContext(authContextInput);
+    return mergeHeaderRecord(base, createCanonicalAuthHeaders(authContext));
   }
   async function fetchWithTimeout(url, init, timeoutMs) {
     const controller = new AbortController();
@@ -340,11 +532,11 @@ function createGatewayRequestClient(config = {}) {
 function asRecord(value) {
   return value && typeof value === "object" ? value : {};
 }
-function cleanString(value) {
+function cleanString2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function normalizeVerificationStatus(value) {
-  const status = cleanString(value);
+  const status = cleanString2(value);
   if (!status) {
     return void 0;
   }
@@ -360,20 +552,20 @@ function cloneWith(value, patch) {
   return { ...value, ...patch };
 }
 function resolveTopicId(value) {
-  return cleanString(value.topicId);
+  return cleanString2(value.topicId);
 }
 function resolveText(value) {
-  return cleanString(value.text) ?? cleanString(value.canonicalText);
+  return cleanString2(value.text) ?? cleanString2(value.canonicalText);
 }
 function withTopicAlias(value) {
-  const topicId = cleanString(value.topicId) ?? void 0;
+  const topicId = cleanString2(value.topicId) ?? void 0;
   if (!topicId) {
     return value;
   }
   return cloneWith(value, { topicId });
 }
 function withTextAlias(value) {
-  const text = cleanString(value.text) ?? cleanString(value.canonicalText) ?? void 0;
+  const text = cleanString2(value.text) ?? cleanString2(value.canonicalText) ?? void 0;
   if (!text) {
     return value;
   }
@@ -403,7 +595,7 @@ function normalizeNodeVerificationStatus(value) {
   return normalizeVerificationStatus(value);
 }
 function normalizeTopicQuery(value) {
-  const topicId = cleanString(value.topicId);
+  const topicId = cleanString2(value.topicId);
   if (!topicId) {
     return value;
   }
@@ -476,9 +668,9 @@ function createAdminClient(config = {}) {
     /**
      * List tenants visible to the current principal.
      */
-    async listTenants(query = {}) {
+    async listTenants(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/tenants${toQueryString(query)}`
+        path: `/api/platform/v1/tenants${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -519,9 +711,9 @@ function createAdminClient(config = {}) {
     /**
      * List workspaces for the current admin scope.
      */
-    async listWorkspaces(query = {}) {
+    async listWorkspaces(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/workspaces${toQueryString(query)}`
+        path: `/api/platform/v1/workspaces${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -546,9 +738,9 @@ function createAdminClient(config = {}) {
     /**
      * List memberships for the current admin scope.
      */
-    async listMemberships(query = {}) {
+    async listMemberships(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/memberships${toQueryString(query)}`
+        path: `/api/platform/v1/memberships${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -785,9 +977,9 @@ function createAdminClient(config = {}) {
     /**
      * List group members.
      */
-    async listGroupMembers(query) {
+    async listGroupMembers(query5) {
       return gateway.request({
-        path: `/api/platform/v1/groups/members${toQueryString(query)}`
+        path: `/api/platform/v1/groups/members${toQueryString(query5)}`
       });
     },
     /**
@@ -814,9 +1006,9 @@ function createAdminClient(config = {}) {
     /**
      * List pack-to-group assignments.
      */
-    async listPackGroupAssignments(query = {}) {
+    async listPackGroupAssignments(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/groups/packs${toQueryString(query)}`
+        path: `/api/platform/v1/groups/packs${toQueryString(query5)}`
       });
     },
     /**
@@ -867,12 +1059,12 @@ function createAudiencesClient(config = {}) {
     /**
      * List audience registry entries.
      */
-    async listRegistry(query = {}) {
+    async listRegistry(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/audiences/registry${toQueryString({
-          ...query,
-          effective: typeof query.effective === "boolean" ? query.effective ? "true" : "false" : void 0,
-          status: query.status
+          ...query5,
+          effective: typeof query5.effective === "boolean" ? query5.effective ? "true" : "false" : void 0,
+          status: query5.status
         })}`
       }).then(
         (response) => mapGatewayData(
@@ -887,8 +1079,8 @@ function createAudiencesClient(config = {}) {
     /**
      * @deprecated Use listRegistry.
      */
-    async getRegistry(query = {}) {
-      return this.listRegistry(query);
+    async getRegistry(query5 = {}) {
+      return this.listRegistry(query5);
     },
     /**
      * Create an audience registry entry.
@@ -916,14 +1108,14 @@ function createAudiencesClient(config = {}) {
     /**
      * List audience grants.
      */
-    async listGrants(query = {}) {
+    async listGrants(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/audiences/grants${toQueryString({
-          ...query,
-          audienceKey: query.audienceKey,
-          principalId: query.principalId,
-          groupId: query.groupId,
-          status: query.status
+          ...query5,
+          audienceKey: query5.audienceKey,
+          principalId: query5.principalId,
+          groupId: query5.groupId,
+          status: query5.status
         })}`
       }).then(
         (response) => mapGatewayData(
@@ -935,8 +1127,8 @@ function createAudiencesClient(config = {}) {
     /**
      * @deprecated Use listGrants.
      */
-    async getGrants(query = {}) {
-      return this.listGrants(query);
+    async getGrants(query5 = {}) {
+      return this.listGrants(query5);
     },
     /**
      * Create an audience grant.
@@ -982,10 +1174,10 @@ function createAuditClient(config = {}) {
     /**
      * List audit events for the current scope.
      */
-    async listEvents(query = {}) {
+    async listEvents(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/audit/events${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       }).then(
         (response) => mapGatewayData(
@@ -997,11 +1189,116 @@ function createAuditClient(config = {}) {
   };
 }
 
+// src/authDeviceClient.ts
+var DeviceAuthorizationError = class extends Error {
+  error;
+  interval;
+  constructor(args) {
+    super(args.description ?? args.error);
+    this.name = "DeviceAuthorizationError";
+    this.error = args.error;
+    this.interval = args.interval;
+  }
+};
+function authBaseUrl(config) {
+  return config.baseUrl?.replace(/\/+$/, "") ?? "";
+}
+async function readJson(response) {
+  const payload = await response.json().catch(() => ({}));
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function readString(value) {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  return normalized || void 0;
+}
+function assertDeviceCodeResponse(payload) {
+  const deviceCode = readString(payload.device_code);
+  const userCode = readString(payload.user_code);
+  const verificationUri = readString(payload.verification_uri);
+  const verificationUriComplete = readString(payload.verification_uri_complete);
+  const expiresIn = payload.expires_in;
+  const interval = payload.interval;
+  if (!deviceCode || !userCode || !verificationUri || !verificationUriComplete || typeof expiresIn !== "number" || typeof interval !== "number") {
+    throw new Error("Gateway returned an invalid device-code response.");
+  }
+  return {
+    device_code: deviceCode,
+    user_code: userCode,
+    verification_uri: verificationUri,
+    verification_uri_complete: verificationUriComplete,
+    expires_in: expiresIn,
+    interval
+  };
+}
+function assertDeviceTokenResponse(payload) {
+  const accessToken = readString(payload.access_token);
+  const tokenType = readString(payload.token_type);
+  const scope = readString(payload.scope);
+  const tenantId = readString(payload.tenant_id);
+  const principalId = readString(payload.principal_id);
+  if (!accessToken || tokenType !== "Bearer" || typeof payload.expires_in !== "number" || !scope || !tenantId || !principalId) {
+    throw new Error("Gateway returned an invalid device token response.");
+  }
+  return {
+    access_token: accessToken,
+    token_type: "Bearer",
+    expires_in: payload.expires_in,
+    scope,
+    tenant_id: tenantId,
+    workspace_id: readString(payload.workspace_id),
+    principal_id: principalId,
+    user: payload.user && typeof payload.user === "object" && !Array.isArray(payload.user) ? payload.user : void 0
+  };
+}
+function maybeThrowDeviceError(payload) {
+  const error = readString(payload.error);
+  throw new DeviceAuthorizationError({
+    error: error ?? "invalid_request",
+    description: readString(payload.error_description),
+    interval: typeof payload.interval === "number" ? payload.interval : void 0
+  });
+}
+function createAuthDeviceClient(config = {}) {
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const baseUrl = authBaseUrl(config);
+  async function post(path, body4) {
+    return fetchImpl(`${baseUrl}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body4)
+    });
+  }
+  return {
+    async createDeviceCode(input = {}) {
+      const response = await post("/api/platform/v1/auth/device/code", {
+        client_id: input.clientId ?? "lucern-cli",
+        scope: input.scope ?? "graph.read graph.write"
+      });
+      const payload = await readJson(response);
+      if (!response.ok) {
+        maybeThrowDeviceError(payload);
+      }
+      return assertDeviceCodeResponse(payload);
+    },
+    async pollDeviceToken(deviceCode) {
+      const response = await post("/api/platform/v1/auth/device/token", {
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode
+      });
+      const payload = await readJson(response);
+      if (!response.ok) {
+        maybeThrowDeviceError(payload);
+      }
+      return assertDeviceTokenResponse(payload);
+    }
+  };
+}
+
 // src/beliefsClient.ts
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function readString(value) {
+function readString2(value) {
   if (typeof value !== "string") {
     return void 0;
   }
@@ -1038,15 +1335,15 @@ function mapOpinionHistoryEntriesFromGatewayData(payload) {
     const record = asRecord2(value);
     const tuple = normalizeOpinionTuple(record);
     const projected = readNumber(record.confidence) ?? clamp01(tuple.b + tuple.a * tuple.u);
-    const triggeringEvidenceId = readString(record.triggeringEvidenceId);
-    const triggeringQuestionId = readString(record.triggeringQuestionId);
-    const triggeringAnswerId = readString(record.triggeringAnswerId);
-    const triggeringContradictionId = readString(
+    const triggeringEvidenceId = readString2(record.triggeringEvidenceId);
+    const triggeringQuestionId = readString2(record.triggeringQuestionId);
+    const triggeringAnswerId = readString2(record.triggeringAnswerId);
+    const triggeringContradictionId = readString2(
       record.triggeringContradictionId
     );
-    const triggeringWorktreeId = readString(record.triggeringWorktreeId);
+    const triggeringWorktreeId = readString2(record.triggeringWorktreeId);
     const triggeringRef = triggeringEvidenceId ? { kind: "evidence", id: triggeringEvidenceId } : triggeringQuestionId ? { kind: "question", id: triggeringQuestionId } : triggeringAnswerId ? { kind: "answer", id: triggeringAnswerId } : triggeringContradictionId ? { kind: "contradiction", id: triggeringContradictionId } : triggeringWorktreeId ? { kind: "worktree", id: triggeringWorktreeId } : void 0;
-    const trigger = readString(record.trigger);
+    const trigger = readString2(record.trigger);
     if (!trigger) {
       throw new Error("Gateway opinion history entries must include trigger.");
     }
@@ -1059,9 +1356,9 @@ function mapOpinionHistoryEntriesFromGatewayData(payload) {
       P: clamp01(projected),
       trigger,
       ...triggeringRef ? { triggeringRef } : {},
-      ...readString(record.rationale) ? { rationale: readString(record.rationale) } : {},
-      ...readString(record.userId) ? { userId: readString(record.userId) } : {},
-      ...readString(record.slOperator) ? { slOperator: readString(record.slOperator) } : {}
+      ...readString2(record.rationale) ? { rationale: readString2(record.rationale) } : {},
+      ...readString2(record.userId) ? { userId: readString2(record.userId) } : {},
+      ...readString2(record.slOperator) ? { slOperator: readString2(record.slOperator) } : {}
     };
   }).sort((left, right) => left.t - right.t);
 }
@@ -1296,6 +1593,180 @@ function createEvidenceClient(config = {}) {
     }
   };
 }
+
+// src/boundaryClientSurface.ts
+function cleanOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function cleanRequiredString(value, label) {
+  const normalized = cleanOptionalString(value);
+  if (!normalized) {
+    throw new Error(`${label} is required`);
+  }
+  return normalized;
+}
+function readTopicId(input) {
+  return cleanOptionalString(input.topicId) ?? cleanOptionalString(input.projectId);
+}
+function requireTopicId(input) {
+  const topicId = readTopicId(input);
+  if (!topicId) {
+    throw new Error("topicId is required");
+  }
+  return topicId;
+}
+function assertKnownKeys(input, allowed, operation) {
+  const allowedSet = new Set(allowed);
+  const unknownKeys = Object.keys(input).filter((key) => !allowedSet.has(key));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `${operation} received unsupported field(s): ${unknownKeys.join(", ")}`
+    );
+  }
+}
+function knownPayload(input, allowed, operation) {
+  assertKnownKeys(input, allowed, operation);
+  return { ...input };
+}
+function topicPayload(input, allowed, operation) {
+  assertKnownKeys(input, allowed, operation);
+  return {
+    ...input,
+    topicId: requireTopicId(input),
+    projectId: void 0
+  };
+}
+function listResultFromEnvelope(data, legacyKey) {
+  const record = data && typeof data === "object" ? data : {};
+  return createListResult(
+    Array.isArray(record[legacyKey]) ? record[legacyKey] : Array.isArray(data) ? data : [],
+    legacyKey
+  );
+}
+
+// src/eventingClient.ts
+var EVENTING_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "principalId",
+  "topicId",
+  "eventId",
+  "eventType",
+  "eventPayload",
+  "webhookId",
+  "deliveryId",
+  "status",
+  "attempt",
+  "statusCode",
+  "error",
+  "responseBody",
+  "durationMs",
+  "metadata",
+  "limit",
+  "cursor"
+];
+function query(input) {
+  return {
+    tenantId: cleanRequiredString(input.tenantId, "tenantId"),
+    workspaceId: input.workspaceId,
+    principalId: input.principalId,
+    topicId: input.topicId,
+    eventType: input.eventType,
+    webhookId: input.webhookId,
+    status: input.status,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function body(input, operation) {
+  return knownPayload(input, EVENTING_FIELDS, operation);
+}
+function createEventingClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    recordEvent(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.eventType, "eventType");
+      return gateway.request({
+        path: "/api/platform/v1/events",
+        method: "POST",
+        body: body(
+          input,
+          "events.recordEvent"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    listEvents(input) {
+      return gateway.request({
+        path: `/api/platform/v1/events${toQueryString(query(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "events")
+        )
+      );
+    },
+    listWebhooks(input) {
+      return gateway.request({
+        path: `/api/platform/v1/webhooks${toQueryString(query(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "webhooks"
+          )
+        )
+      );
+    },
+    enqueueDelivery(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.eventId, "eventId");
+      cleanRequiredString(input.webhookId, "webhookId");
+      return gateway.request({
+        path: "/api/platform/v1/events/deliveries",
+        method: "POST",
+        body: body(
+          input,
+          "events.enqueueDelivery"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    recordDeliveryAttempt(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.deliveryId, "deliveryId");
+      return gateway.request({
+        path: `/api/platform/v1/events/deliveries/${encodeURIComponent(
+          input.deliveryId
+        )}/attempts`,
+        method: "POST",
+        body: body(
+          input,
+          "events.recordDeliveryAttempt"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    updateDeliveryStatus(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.deliveryId, "deliveryId");
+      return gateway.request({
+        path: `/api/platform/v1/events/deliveries/${encodeURIComponent(
+          input.deliveryId
+        )}/status`,
+        method: "PATCH",
+        body: body(
+          input,
+          "events.updateDeliveryStatus"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
 var DEFAULT_CUSTOM_NAMESPACE = "custom";
 var RESERVED_NAMESPACES = /* @__PURE__ */ new Set(["lucern"]);
 var CustomToolRegistryError = class extends Error {
@@ -1701,10 +2172,10 @@ function createGraphClient(config = {}) {
     /**
      * List graph nodes matching the provided filters.
      */
-    async listNodes(query) {
+    async listNodes(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/nodes${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       }).then(
         (response) => mapGatewayData(response, (data) => mapAliasedList(data, "nodes"))
@@ -1713,15 +2184,15 @@ function createGraphClient(config = {}) {
     /**
      * @deprecated Use listNodes.
      */
-    async queryNodes(query) {
-      return this.listNodes(query);
+    async queryNodes(query5) {
+      return this.listNodes(query5);
     },
     /**
      * Retrieve a single graph node by nodeId or globalId.
      */
-    async getNode(query) {
+    async getNode(query5) {
       return gateway.request({
-        path: `/api/platform/v1/graph/nodes${toQueryString(query)}`
+        path: `/api/platform/v1/graph/nodes${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -1814,10 +2285,10 @@ function createGraphClient(config = {}) {
     /**
      * List graph edges matching the provided filters.
      */
-    async listEdges(query) {
+    async listEdges(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/edges${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       }).then(
         (response) => mapGatewayData(
@@ -1829,8 +2300,8 @@ function createGraphClient(config = {}) {
     /**
      * @deprecated Use listEdges.
      */
-    async queryEdges(query) {
-      return this.listEdges(query);
+    async queryEdges(query5) {
+      return this.listEdges(query5);
     },
     /**
      * Create a graph edge.
@@ -1846,9 +2317,9 @@ function createGraphClient(config = {}) {
     /**
      * Delete one or more edges matching the provided filter.
      */
-    async deleteEdge(query, idempotencyKey) {
+    async deleteEdge(query5, idempotencyKey) {
       return gateway.request({
-        path: `/api/platform/v1/graph/edges${toQueryString(query)}`,
+        path: `/api/platform/v1/graph/edges${toQueryString(query5)}`,
         method: "DELETE",
         idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
       });
@@ -1856,26 +2327,26 @@ function createGraphClient(config = {}) {
     /**
      * Retrieve a graph neighborhood around a root node.
      */
-    async neighborhood(query) {
+    async neighborhood(query5) {
       return gateway.request({
-        path: `/api/platform/v1/graph/neighborhood${toQueryString(query)}`
+        path: `/api/platform/v1/graph/neighborhood${toQueryString(query5)}`
       });
     },
     /**
      * Traverse the graph from a starting node.
      */
-    async traverse(query) {
+    async traverse(query5) {
       return gateway.request({
         path: "/api/platform/v1/graph/traverse",
         method: "POST",
-        body: normalizeTopicQuery(query)
+        body: normalizeTopicQuery(query5)
       });
     },
     /**
      * Analyze graph structure for a topic.
      */
-    async analyze(query = {}) {
-      const normalized = normalizeTopicQuery(query);
+    async analyze(query5 = {}) {
+      const normalized = normalizeTopicQuery(query5);
       return gateway.request({
         path: `/api/platform/v1/graph/analyze${toQueryString({
           topicId: typeof normalized.topicId === "string" ? normalized.topicId : void 0,
@@ -1887,8 +2358,8 @@ function createGraphClient(config = {}) {
     /**
      * Detect confirmation-bias patterns for a topic graph.
      */
-    async bias(query = {}) {
-      const normalized = normalizeTopicQuery(query);
+    async bias(query5 = {}) {
+      const normalized = normalizeTopicQuery(query5);
       return gateway.request({
         path: `/api/platform/v1/graph/bias${toQueryString({
           topicId: typeof normalized.topicId === "string" ? normalized.topicId : void 0,
@@ -1900,8 +2371,8 @@ function createGraphClient(config = {}) {
     /**
      * Find graph gaps for beliefs that still need testing.
      */
-    async gaps(query) {
-      const normalized = normalizeTopicQuery(query);
+    async gaps(query5) {
+      const normalized = normalizeTopicQuery(query5);
       return gateway.request({
         path: `/api/platform/v1/graph/gaps${toQueryString({
           topicId: typeof normalized.topicId === "string" ? normalized.topicId : void 0,
@@ -1912,33 +2383,33 @@ function createGraphClient(config = {}) {
     /**
      * Search across graph resources within a topic.
      */
-    async search(query) {
+    async search(query5) {
       return gateway.request({
         path: "/api/platform/v1/search",
         method: "POST",
-        body: normalizeTopicQuery(query)
+        body: normalizeTopicQuery(query5)
       });
     },
     /**
      * Retrieve a graph neighborhood around a root node.
      */
-    async getNeighborhood(query) {
-      return this.neighborhood(query);
+    async getNeighborhood(query5) {
+      return this.neighborhood(query5);
     },
     /**
      * Retrieve the shortest known path between two graph nodes.
      */
-    async getPath(query) {
+    async getPath(query5) {
       return gateway.request({
-        path: `/api/platform/v1/graph/path${toQueryString(query)}`
+        path: `/api/platform/v1/graph/path${toQueryString(query5)}`
       });
     },
     /**
      * Retrieve graph analytics for the requested metric.
      */
-    async getAnalytics(query = {}) {
+    async getAnalytics(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/graph/analytics${toQueryString(query)}`
+        path: `/api/platform/v1/graph/analytics${toQueryString(query5)}`
       });
     }
   };
@@ -1955,6 +2426,37 @@ function createIdentityWhoamiClient(config = {}) {
     }
   };
 }
+var TENANT_IDENTITY_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "principalId",
+  "integrationKey",
+  "secretRef",
+  "policySubject",
+  "policyAction",
+  "policyResource",
+  "decision",
+  "config",
+  "configKey",
+  "configValue",
+  "provider",
+  "status",
+  "metadata",
+  "limit",
+  "cursor"
+];
+function tenantIdentityQuery(input) {
+  return {
+    tenantId: cleanRequiredString(input.tenantId, "tenantId"),
+    workspaceId: input.workspaceId,
+    principalId: input.principalId,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function tenantIdentityBody(input, operation) {
+  return knownPayload(input, TENANT_IDENTITY_FIELDS, operation);
+}
 function createIdentityClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
   const whoamiClient = createIdentityWhoamiClient(config);
@@ -1990,9 +2492,9 @@ function createIdentityClient(config = {}) {
     /**
      * List principals in the current identity scope.
      */
-    async listPrincipals(query = {}) {
+    async listPrincipals(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/identity/principals${toQueryString(query)}`
+        path: `/api/platform/v1/identity/principals${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -2024,9 +2526,9 @@ function createIdentityClient(config = {}) {
     /**
      * List keys in the current identity scope.
      */
-    async listKeys(query = {}) {
+    async listKeys(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/identity/keys${toQueryString(query)}`
+        path: `/api/platform/v1/identity/keys${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -2080,6 +2582,109 @@ function createIdentityClient(config = {}) {
       return gateway.request({
         path: `/api/platform/v1/identity/clerk-users${toQueryString({ q })}`
       });
+    },
+    async getTenantConfig(input) {
+      return gateway.request({
+        path: `/api/platform/v1/identity/tenant-config${toQueryString(
+          tenantIdentityQuery(input)
+        )}`
+      });
+    },
+    async updateTenantConfig(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      return gateway.request({
+        path: "/api/platform/v1/identity/tenant-config",
+        method: "PATCH",
+        body: tenantIdentityBody(
+          input,
+          "identity.updateTenantConfig"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    async listIntegrations(input) {
+      return gateway.request({
+        path: `/api/platform/v1/identity/integrations${toQueryString(
+          tenantIdentityQuery(input)
+        )}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "integrations"
+          )
+        )
+      );
+    },
+    async upsertIntegration(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.integrationKey, "integrationKey");
+      return gateway.request({
+        path: "/api/platform/v1/identity/integrations",
+        method: "PUT",
+        body: tenantIdentityBody(
+          input,
+          "identity.upsertIntegration"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    async listSecrets(input) {
+      return gateway.request({
+        path: `/api/platform/v1/identity/secrets${toQueryString(
+          tenantIdentityQuery(input)
+        )}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "secrets"
+          )
+        )
+      );
+    },
+    async putSecretReference(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.secretRef, "secretRef");
+      return gateway.request({
+        path: "/api/platform/v1/identity/secrets",
+        method: "PUT",
+        body: tenantIdentityBody(
+          input,
+          "identity.putSecretReference"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    async evaluatePolicy(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.policySubject, "policySubject");
+      cleanRequiredString(input.policyAction, "policyAction");
+      cleanRequiredString(input.policyResource, "policyResource");
+      return gateway.request({
+        path: "/api/platform/v1/identity/policy/evaluate",
+        method: "POST",
+        body: tenantIdentityBody(
+          input,
+          "identity.evaluatePolicy"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    async recordPolicyDecision(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.decision, "decision");
+      return gateway.request({
+        path: "/api/platform/v1/identity/policy/decisions",
+        method: "POST",
+        body: tenantIdentityBody(
+          input,
+          "identity.recordPolicyDecision"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
     }
   };
 }
@@ -2088,12 +2693,12 @@ function createIdentityClient(config = {}) {
 function asRecord3(value) {
   return value && typeof value === "object" ? value : {};
 }
-function cleanString2(value) {
+function cleanString3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function normalizeTopicRecord(value) {
   const record = asRecord3(value);
-  const topicId = cleanString2(record.topicId) ?? cleanString2(record.id) ?? cleanString2(record._id);
+  const topicId = cleanString3(record.topicId) ?? cleanString3(record.id) ?? cleanString3(record._id);
   return withTopicAlias({
     ...record,
     ...topicId ? { topicId } : {}
@@ -2105,15 +2710,15 @@ function normalizeTopicTreeNode(value) {
 function createTopicsClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
   return {
-    async list(query = {}) {
-      const topicId = resolveTopicId(query);
+    async list(query5 = {}) {
+      const topicId = resolveTopicId(query5);
       return gateway.request({
         path: `/api/platform/v1/topics${toQueryString({
           ...topicId ? { topicId } : {},
-          ontologyId: query.ontologyId,
-          parentTopicId: query.parentTopicId,
-          status: query.status,
-          type: query.type
+          ontologyId: query5.ontologyId,
+          parentTopicId: query5.parentTopicId,
+          status: query5.status,
+          type: query5.type
         })}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
@@ -2163,10 +2768,10 @@ function createTopicsClient(config = {}) {
         (response) => mapGatewayData(response, (data) => normalizeTopicRecord(data))
       );
     },
-    async getTree(topicId, query = {}) {
+    async getTree(topicId, query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/topics/${encodeURIComponent(topicId)}/tree${toQueryString(
-          query
+          query5
         )}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
@@ -2177,10 +2782,10 @@ function createTopicsClient(config = {}) {
         })
       );
     },
-    async getCoverage(topicId, query = {}) {
+    async getCoverage(topicId, query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/topics/${encodeURIComponent(topicId)}/coverage${toQueryString(
-          query
+          query5
         )}`
       });
     },
@@ -2240,15 +2845,15 @@ function createBeliefsFacade(config = {}) {
         path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/beliefs${toQueryString({
-          topicId: query.topicId,
-          status: query.status,
-          worktreeId: query.worktreeId,
-          minConfidence: query.minConfidence,
-          limit: query.limit,
-          cursor: query.cursor
+          topicId: query5.topicId,
+          status: query5.status,
+          worktreeId: query5.worktreeId,
+          minConfidence: query5.minConfidence,
+          limit: query5.limit,
+          cursor: query5.cursor
         })}`
       });
     },
@@ -2384,13 +2989,13 @@ function createContradictionsFacade(config = {}) {
         idempotencyKey
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/contradictions${toQueryString({
-          topicId: query.topicId,
-          status: query.status,
-          limit: query.limit,
-          cursor: query.cursor
+          topicId: query5.topicId,
+          status: query5.status,
+          limit: query5.limit,
+          cursor: query5.cursor
         })}`
       });
     },
@@ -2412,13 +3017,13 @@ function createEdgesFacade(config = {}) {
         idempotencyKey
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/edges${toQueryString({
-          sourceId: query.sourceId,
-          edgeType: query.edgeType,
-          limit: query.limit,
-          cursor: query.cursor
+          sourceId: query5.sourceId,
+          edgeType: query5.edgeType,
+          limit: query5.limit,
+          cursor: query5.cursor
         })}`
       });
     },
@@ -2488,13 +3093,13 @@ function createEvidenceFacade(config = {}) {
         path: `/api/platform/v1/evidence/${encodeURIComponent(id)}`
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/evidence${toQueryString({
-          topicId: query.topicId,
-          targetId: query.targetId,
-          limit: query.limit,
-          cursor: query.cursor
+          topicId: query5.topicId,
+          targetId: query5.targetId,
+          limit: query5.limit,
+          cursor: query5.cursor
         })}`
       });
     },
@@ -2511,11 +3116,11 @@ function createEvidenceFacade(config = {}) {
         idempotencyKey
       });
     },
-    async search(query, idempotencyKey = randomIdempotencyKey()) {
+    async search(query5, idempotencyKey = randomIdempotencyKey()) {
       return gateway.request({
         path: "/api/platform/v1/evidence/search",
         method: "POST",
-        body: query,
+        body: query5,
         idempotencyKey
       });
     },
@@ -2564,15 +3169,15 @@ function createEvidenceFacade(config = {}) {
 function createEventsFacade(config = {}) {
   const gateway = createGatewayRequestClient(config);
   return {
-    async list(query = {}) {
+    async list(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/events${toQueryString({
-          topicId: query.topicId,
-          after: query.after,
-          types: serializeTypes(query.types),
-          startTime: query.startTime,
-          endTime: query.endTime,
-          limit: query.limit
+          topicId: query5.topicId,
+          after: query5.after,
+          types: serializeTypes(query5.types),
+          startTime: query5.startTime,
+          endTime: query5.endTime,
+          limit: query5.limit
         })}`
       });
     },
@@ -2637,8 +3242,8 @@ function createOntologiesFacade(config = {}) {
         path: `/api/platform/v1/ontologies/${encodeURIComponent(id)}`
       });
     },
-    async list(query = {}) {
-      return ontologyClient.list(query);
+    async list(query5 = {}) {
+      return ontologyClient.list(query5);
     },
     async bind(input, idempotencyKey) {
       return gateway.request({
@@ -2676,15 +3281,15 @@ function createQuestionsFacade(config = {}) {
         path: `/api/platform/v1/questions/${encodeURIComponent(id)}`
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/questions${toQueryString({
-          topicId: query.topicId,
-          status: query.status,
-          priority: query.priority,
-          worktreeId: query.worktreeId,
-          limit: query.limit,
-          cursor: query.cursor
+          topicId: query5.topicId,
+          status: query5.status,
+          priority: query5.priority,
+          worktreeId: query5.worktreeId,
+          limit: query5.limit,
+          cursor: query5.cursor
         })}`
       });
     },
@@ -2836,13 +3441,13 @@ function createTasksFacade(config = {}) {
         idempotencyKey
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/tasks${toQueryString({
-          topicId: query.topicId,
-          worktreeId: query.worktreeId,
-          status: query.status,
-          limit: query.limit
+          topicId: query5.topicId,
+          worktreeId: query5.worktreeId,
+          status: query5.status,
+          limit: query5.limit
         })}`
       });
     }
@@ -2857,8 +3462,8 @@ function createTopicsFacade(config = {}) {
     async get(id) {
       return topicsClient.get(id);
     },
-    async list(query = {}) {
-      return topicsClient.list(query);
+    async list(query5 = {}) {
+      return topicsClient.list(query5);
     },
     async update(input, idempotencyKey) {
       const { id, ...rest } = input;
@@ -2894,10 +3499,10 @@ function createWebhooksFacade(config = {}) {
         idempotencyKey
       });
     },
-    async list(query = {}) {
+    async list(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/webhooks${toQueryString({
-          topicId: query.topicId
+          topicId: query5.topicId
         })}`
       });
     },
@@ -2929,10 +3534,10 @@ function createWebhooksFacade(config = {}) {
         idempotencyKey
       });
     },
-    async deliveries(id, query = {}) {
+    async deliveries(id, query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/deliveries${toQueryString({
-          limit: query.limit
+          limit: query5.limit
         })}`
       });
     },
@@ -2954,24 +3559,24 @@ function createWorktreesFacade(config = {}) {
         idempotencyKey
       });
     },
-    async list(query) {
+    async list(query5) {
       return gateway.request({
         path: `/api/platform/v1/worktrees${toQueryString({
-          topicId: query.topicId,
-          status: query.status,
-          groupBy: query.groupBy,
-          lane: query.lane,
-          campaign: query.campaign,
-          limit: query.limit
+          topicId: query5.topicId,
+          status: query5.status,
+          groupBy: query5.groupBy,
+          lane: query5.lane,
+          campaign: query5.campaign,
+          limit: query5.limit
         })}`
       });
     },
-    async listCampaigns(query = {}) {
+    async listCampaigns(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/worktrees/campaigns${toQueryString({
-          topicId: query.topicId,
-          status: query.status,
-          limit: query.limit
+          topicId: query5.topicId,
+          status: query5.status,
+          limit: query5.limit
         })}`
       });
     },
@@ -3084,12 +3689,12 @@ function createDecisionsClient(config = {}) {
     /**
      * List judgments for a topic scope.
      */
-    async listJudgments(query) {
+    async listJudgments(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/judgments${toQueryString({
-          ...normalizeTopicQuery(query),
-          includeArchived: typeof query.includeArchived === "boolean" ? query.includeArchived ? "true" : "false" : void 0,
-          limit: query.limit
+          ...normalizeTopicQuery(query5),
+          includeArchived: typeof query5.includeArchived === "boolean" ? query5.includeArchived ? "true" : "false" : void 0,
+          limit: query5.limit
         })}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
@@ -3121,30 +3726,30 @@ function createDecisionsClient(config = {}) {
     /**
      * Get readiness signals for creating a judgment.
      */
-    async getJudgmentReadiness(query) {
+    async getJudgmentReadiness(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/judgments/readiness${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       });
     },
     /**
      * Get calibration analytics for judgment outcomes.
      */
-    async getJudgmentCalibration(query) {
+    async getJudgmentCalibration(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/judgments/calibration${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       });
     },
     /**
      * List judgments still awaiting outcome review.
      */
-    async listPendingOutcomeReviews(query) {
+    async listPendingOutcomeReviews(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/judgments/pending-outcome-review${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
@@ -3161,19 +3766,19 @@ function createDecisionsClient(config = {}) {
     /**
      * @deprecated Use listPendingOutcomeReviews.
      */
-    async listPendingJudgmentOutcomeReview(query) {
-      return this.listPendingOutcomeReviews(query);
+    async listPendingJudgmentOutcomeReview(query5) {
+      return this.listPendingOutcomeReviews(query5);
     },
     /**
      * Get audit integrity checks for judgment transitions.
      */
-    async getJudgmentTransitionAuditIntegrity(query) {
+    async getJudgmentTransitionAuditIntegrity(query5) {
       return gateway.request({
         path: `/api/platform/v1/graph/judgments/transition-audit-integrity${toQueryString(
           {
-            ...normalizeTopicQuery(query),
-            judgmentId: query.judgmentId,
-            includePassing: typeof query.includePassing === "boolean" ? query.includePassing ? "true" : "false" : void 0
+            ...normalizeTopicQuery(query5),
+            judgmentId: query5.judgmentId,
+            includePassing: typeof query5.includePassing === "boolean" ? query5.includePassing ? "true" : "false" : void 0
           }
         )}`
       });
@@ -3222,58 +3827,170 @@ function createDecisionsClient(config = {}) {
   };
 }
 
-// src/contextClient.ts
-function cleanString3(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function cleanNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+// src/embeddingsClient.ts
+var EMBEDDINGS_FIELDS = [
+  "topicId",
+  "projectId",
+  "workspaceId",
+  "nodeIds",
+  "nodeType",
+  "embeddingModel",
+  "queryText",
+  "queryVector",
+  "minScore",
+  "limit",
+  "cursor",
+  "metadata"
+];
+function assertNodeIds(nodeIds) {
+  if (!Array.isArray(nodeIds) || nodeIds.length === 0) {
+    throw new Error("nodeIds is required");
+  }
 }
-function cleanBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
+function missingQuery(input) {
+  return {
+    topicId: requireTopicId(input),
+    workspaceId: cleanRequiredString(input.workspaceId, "workspaceId"),
+    nodeType: input.nodeType,
+    embeddingModel: input.embeddingModel,
+    limit: input.limit,
+    cursor: input.cursor
+  };
 }
-function buildCompileContextRequest(topicId, input = {}) {
-  const payload = { topicId };
-  const query = cleanString3(input.query);
-  if (query) {
-    payload.query = query;
-  }
-  const budget = cleanNumber(input.budget) ?? cleanNumber(input.tokenBudget);
-  if (budget !== void 0) {
-    payload.budget = budget;
-  }
-  const ranking = cleanString3(input.ranking) ?? cleanString3(input.rankingProfile);
-  if (ranking) {
-    payload.ranking = ranking;
-  }
-  const limit = cleanNumber(input.limit);
-  if (limit !== void 0) {
-    payload.limit = limit;
-  }
-  const maxDepth = cleanNumber(input.maxDepth);
-  if (maxDepth !== void 0) {
-    payload.maxDepth = maxDepth;
-  }
-  const includeEntities = cleanBoolean(input.includeEntities);
-  if (includeEntities !== void 0) {
-    payload.includeEntities = includeEntities;
-  }
-  const mode = cleanString3(input.mode);
-  if (mode) {
-    payload.mode = mode;
-  }
-  const includeFailures = cleanBoolean(input.includeFailures);
-  if (includeFailures !== void 0) {
-    payload.includeFailures = includeFailures;
-  }
-  const worktreeId = cleanString3(input.worktreeId);
-  if (worktreeId) {
-    payload.worktreeId = worktreeId;
-  }
-  const sessionId = cleanString3(input.sessionId);
-  if (sessionId) {
-    payload.sessionId = sessionId;
-  }
+function createEmbeddingsClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    getByNodeIds(input) {
+      assertNodeIds(input.nodeIds);
+      return gateway.request({
+        path: "/api/platform/v1/embeddings/by-node-ids",
+        method: "POST",
+        body: topicPayload(
+          {
+            ...input,
+            workspaceId: cleanRequiredString(input.workspaceId, "workspaceId")
+          },
+          EMBEDDINGS_FIELDS,
+          "embeddings.getByNodeIds"
+        )
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "embeddings"
+          )
+        )
+      );
+    },
+    listMissingForTopic(input) {
+      return gateway.request({
+        path: `/api/platform/v1/embeddings/missing${toQueryString(
+          missingQuery(input)
+        )}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "nodes"
+          )
+        )
+      );
+    },
+    vectorSearchByTopic(input) {
+      if (!input.queryText && !input.queryVector) {
+        throw new Error("queryText or queryVector is required");
+      }
+      return gateway.request({
+        path: "/api/platform/v1/embeddings/vector-search",
+        method: "POST",
+        body: topicPayload(
+          {
+            ...input,
+            workspaceId: cleanRequiredString(input.workspaceId, "workspaceId")
+          },
+          EMBEDDINGS_FIELDS,
+          "embeddings.vectorSearchByTopic"
+        )
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "results")
+        )
+      );
+    },
+    markEmbeddingBackfillQueued(input, idempotencyKey) {
+      assertNodeIds(input.nodeIds);
+      return gateway.request({
+        path: "/api/platform/v1/embeddings/backfill-queued",
+        method: "POST",
+        body: topicPayload(
+          {
+            ...input,
+            workspaceId: cleanRequiredString(input.workspaceId, "workspaceId")
+          },
+          EMBEDDINGS_FIELDS,
+          "embeddings.markEmbeddingBackfillQueued"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
+// src/contextClient.ts
+function cleanString4(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function cleanNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function cleanBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function buildCompileContextRequest(topicId, input = {}) {
+  const payload = { topicId };
+  const query5 = cleanString4(input.query);
+  if (query5) {
+    payload.query = query5;
+  }
+  const budget = cleanNumber(input.budget) ?? cleanNumber(input.tokenBudget);
+  if (budget !== void 0) {
+    payload.budget = budget;
+  }
+  const ranking = cleanString4(input.ranking) ?? cleanString4(input.rankingProfile);
+  if (ranking) {
+    payload.ranking = ranking;
+  }
+  const limit = cleanNumber(input.limit);
+  if (limit !== void 0) {
+    payload.limit = limit;
+  }
+  const maxDepth = cleanNumber(input.maxDepth);
+  if (maxDepth !== void 0) {
+    payload.maxDepth = maxDepth;
+  }
+  const includeEntities = cleanBoolean(input.includeEntities);
+  if (includeEntities !== void 0) {
+    payload.includeEntities = includeEntities;
+  }
+  const mode = cleanString4(input.mode);
+  if (mode) {
+    payload.mode = mode;
+  }
+  const includeFailures = cleanBoolean(input.includeFailures);
+  if (includeFailures !== void 0) {
+    payload.includeFailures = includeFailures;
+  }
+  const worktreeId = cleanString4(input.worktreeId);
+  if (worktreeId) {
+    payload.worktreeId = worktreeId;
+  }
+  const sessionId = cleanString4(input.sessionId);
+  if (sessionId) {
+    payload.sessionId = sessionId;
+  }
   if (Array.isArray(input.packWeightOverrides) && input.packWeightOverrides.length > 0) {
     payload.packWeightOverrides = input.packWeightOverrides;
   }
@@ -3302,6 +4019,406 @@ function createContextClient(config = {}) {
   };
 }
 
+// src/graphAnalysisClient.ts
+var GRAPH_ANALYSIS_ANALYSIS_FIELDS = [
+  "topicId",
+  "projectId",
+  "workspaceId",
+  "analysisType",
+  "healthScore",
+  "findings",
+  "suggestions",
+  "sourceNodeIds",
+  "sourceEdgeIds",
+  "detectorVersions",
+  "metadata"
+];
+var GRAPH_ANALYSIS_SUGGESTION_FIELDS = [
+  "topicId",
+  "projectId",
+  "workspaceId",
+  "analysisId",
+  "suggestions",
+  "metadata"
+];
+var GRAPH_ANALYSIS_COMPUTE_FIELDS = [
+  "topicId",
+  "projectId",
+  "workspaceId",
+  "analysisType",
+  "sourceNodeIds",
+  "sourceEdgeIds",
+  "detectorVersions",
+  "metadata"
+];
+function readTopicId2(input) {
+  return input.topicId?.trim() || input.projectId?.trim() || void 0;
+}
+function requireTopicId2(input) {
+  const topicId = readTopicId2(input);
+  if (!topicId) {
+    throw new Error("topicId is required");
+  }
+  return topicId;
+}
+function assertKnownKeys2(input, allowed, operation) {
+  const allowedSet = new Set(allowed);
+  const unknownKeys = Object.keys(input).filter((key) => !allowedSet.has(key));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `${operation} received unsupported field(s): ${unknownKeys.join(", ")}`
+    );
+  }
+}
+function normalizeAnalysisPayload(input) {
+  assertKnownKeys2(
+    input,
+    GRAPH_ANALYSIS_ANALYSIS_FIELDS,
+    "graphAnalysis.saveAnalysis"
+  );
+  return {
+    ...input,
+    topicId: requireTopicId2(input),
+    projectId: void 0
+  };
+}
+function normalizeSuggestionPayload(input) {
+  assertKnownKeys2(
+    input,
+    GRAPH_ANALYSIS_SUGGESTION_FIELDS,
+    "graphAnalysis.saveSuggestions"
+  );
+  return {
+    ...input,
+    topicId: requireTopicId2(input),
+    projectId: void 0
+  };
+}
+function normalizeComputePayload(input) {
+  assertKnownKeys2(
+    input,
+    GRAPH_ANALYSIS_COMPUTE_FIELDS,
+    "graphAnalysis.computeOrRequestAnalysis"
+  );
+  return {
+    ...input,
+    topicId: requireTopicId2(input),
+    projectId: void 0
+  };
+}
+function graphAnalysisQuery(input) {
+  return {
+    topicId: requireTopicId2(input),
+    workspaceId: input.workspaceId,
+    analysisType: input.analysisType,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function createGraphAnalysisClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    saveAnalysis(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/graph-analysis/analyses",
+        method: "POST",
+        body: normalizeAnalysisPayload(input),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    listAnalyses(input) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-analysis/analyses${toQueryString(
+          graphAnalysisQuery(input)
+        )}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => createListResult(
+            Array.isArray(data.analyses) ? data.analyses : Array.isArray(data) ? data : [],
+            "analyses"
+          )
+        )
+      );
+    },
+    getLatestAnalysis(input) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-analysis/analyses/latest${toQueryString({
+          topicId: requireTopicId2(input),
+          workspaceId: input.workspaceId,
+          analysisType: input.analysisType
+        })}`
+      });
+    },
+    saveSuggestions(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/graph-analysis/suggestions",
+        method: "POST",
+        body: normalizeSuggestionPayload(input),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    updateSuggestionStatus(input, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-analysis/suggestions/${encodeURIComponent(
+          input.suggestionId
+        )}`,
+        method: "PATCH",
+        body: {
+          status: input.status,
+          rationale: input.rationale,
+          metadata: input.metadata
+        },
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    listSuggestions(input) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-analysis/suggestions${toQueryString({
+          topicId: requireTopicId2(input),
+          workspaceId: input.workspaceId,
+          analysisId: input.analysisId,
+          findingId: input.findingId,
+          status: input.status,
+          limit: input.limit,
+          cursor: input.cursor
+        })}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => createListResult(
+            Array.isArray(data.suggestions) ? data.suggestions : Array.isArray(data) ? data : [],
+            "suggestions"
+          )
+        )
+      );
+    },
+    listGraphChanges(input) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-analysis/changes${toQueryString({
+          topicId: requireTopicId2(input),
+          workspaceId: input.workspaceId,
+          analysisId: input.analysisId,
+          since: input.since,
+          limit: input.limit,
+          cursor: input.cursor
+        })}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => createListResult(
+            Array.isArray(data.changes) ? data.changes : Array.isArray(data) ? data : [],
+            "changes"
+          )
+        )
+      );
+    },
+    computeOrRequestAnalysis(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/graph-analysis/compute",
+        method: "POST",
+        body: normalizeComputePayload(input),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
+// src/graphRecommendationsClient.ts
+var GRAPH_RECOMMENDATION_FIELDS = [
+  "topicId",
+  "projectId",
+  "workspaceId",
+  "limit",
+  "cursor",
+  "status",
+  "findingId",
+  "actionType",
+  "targetNodeIds",
+  "priority",
+  "rationale",
+  "healthScore",
+  "metadata"
+];
+function readTopicId3(input) {
+  return input.topicId?.trim() || input.projectId?.trim() || void 0;
+}
+function requireTopicId3(input) {
+  const topicId = readTopicId3(input);
+  if (!topicId) {
+    throw new Error("topicId is required");
+  }
+  return topicId;
+}
+function assertKnownKeys3(input, operation) {
+  const allowed = new Set(GRAPH_RECOMMENDATION_FIELDS);
+  const unknownKeys = Object.keys(input).filter((key) => !allowed.has(key));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `${operation} received unsupported field(s): ${unknownKeys.join(", ")}`
+    );
+  }
+}
+function listQuery(input) {
+  assertKnownKeys3(
+    input,
+    "graphRecommendations.listForTopic"
+  );
+  return {
+    workspaceId: input.workspaceId,
+    topicId: requireTopicId3(input),
+    limit: input.limit,
+    cursor: input.cursor,
+    status: input.status,
+    findingId: input.findingId,
+    actionType: input.actionType,
+    priority: input.priority,
+    targetNodeIds: input.targetNodeIds?.join(","),
+    healthScore: input.healthScore
+  };
+}
+function createGraphRecommendationsClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    listForTopic(input) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-recommendations${toQueryString(
+          listQuery(input)
+        )}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => createListResult(
+            Array.isArray(
+              data.recommendations
+            ) ? data.recommendations : Array.isArray(data) ? data : [],
+            "recommendations"
+          )
+        )
+      );
+    },
+    getRecommendation(recommendationId) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-recommendations/${encodeURIComponent(
+          recommendationId
+        )}`
+      });
+    },
+    markRecommendationStatus(input, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-recommendations/${encodeURIComponent(
+          input.recommendationId
+        )}/status`,
+        method: "PATCH",
+        body: {
+          status: input.status,
+          rationale: input.rationale,
+          metadata: input.metadata
+        },
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
+// src/graphStateClassifierClient.ts
+var GRAPH_STATE_CLASSIFIER_FIELDS = [
+  "topicId",
+  "projectId",
+  "workspaceId",
+  "nodeId",
+  "epistemicStatus",
+  "beliefMaturity",
+  "answerQuality",
+  "evidenceNetwork",
+  "logicalRole",
+  "questionPriority",
+  "layer",
+  "modelVersion",
+  "limit",
+  "cursor",
+  "metadata"
+];
+function normalizeRecordPayload(input) {
+  cleanRequiredString(input.workspaceId, "workspaceId");
+  cleanRequiredString(input.nodeId, "nodeId");
+  return topicPayload(
+    input,
+    GRAPH_STATE_CLASSIFIER_FIELDS,
+    "graphStateClassifier.recordClassification"
+  );
+}
+function createGraphStateClassifierClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    classifyNode(input, idempotencyKey) {
+      cleanRequiredString(input.workspaceId, "workspaceId");
+      cleanRequiredString(input.nodeId, "nodeId");
+      return gateway.request({
+        path: "/api/platform/v1/graph-state-classifier/classify-node",
+        method: "POST",
+        body: topicPayload(
+          input,
+          GRAPH_STATE_CLASSIFIER_FIELDS,
+          "graphStateClassifier.classifyNode"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    classifyTopic(input, idempotencyKey) {
+      cleanRequiredString(input.workspaceId, "workspaceId");
+      return gateway.request({
+        path: "/api/platform/v1/graph-state-classifier/classify-topic",
+        method: "POST",
+        body: topicPayload(
+          input,
+          GRAPH_STATE_CLASSIFIER_FIELDS,
+          "graphStateClassifier.classifyTopic"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "classifications"
+          )
+        )
+      );
+    },
+    listClassifications(input) {
+      return gateway.request({
+        path: `/api/platform/v1/graph-state-classifier/classifications${toQueryString({
+          topicId: requireTopicId(input),
+          workspaceId: input.workspaceId,
+          nodeId: input.nodeId,
+          modelVersion: input.modelVersion,
+          layer: input.layer,
+          epistemicStatus: input.epistemicStatus,
+          limit: input.limit,
+          cursor: input.cursor
+        })}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(
+            data,
+            "classifications"
+          )
+        )
+      );
+    },
+    recordClassification(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/graph-state-classifier/classifications",
+        method: "POST",
+        body: normalizeRecordPayload(input),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
 // src/harnessClient.ts
 function createHarnessClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
@@ -3521,9 +4638,9 @@ function createHarnessClient(config = {}) {
     /**
      * List prompt resolutions.
      */
-    async listPromptResolutions(query = {}) {
+    async listPromptResolutions(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/harness/prompts${toQueryString(query)}`
+        path: `/api/platform/v1/harness/prompts${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -3542,6 +4659,128 @@ function createHarnessClient(config = {}) {
   };
 }
 
+// src/jobsClient.ts
+var JOBS_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "principalId",
+  "topicId",
+  "worktreeId",
+  "jobId",
+  "jobType",
+  "payload",
+  "status",
+  "attempt",
+  "runId",
+  "queue",
+  "priority",
+  "error",
+  "metadata",
+  "limit",
+  "cursor"
+];
+function query2(input) {
+  return {
+    tenantId: cleanRequiredString(input.tenantId, "tenantId"),
+    workspaceId: input.workspaceId,
+    principalId: input.principalId,
+    topicId: input.topicId,
+    worktreeId: input.worktreeId,
+    jobType: input.jobType,
+    status: input.status,
+    queue: input.queue,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function body2(input, operation) {
+  return knownPayload(input, JOBS_FIELDS, operation);
+}
+function createJobsClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    enqueue(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.jobType, "jobType");
+      return gateway.request({
+        path: "/api/platform/v1/jobs",
+        method: "POST",
+        body: body2(input, "jobs.enqueue"),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    list(input) {
+      return gateway.request({
+        path: `/api/platform/v1/jobs${toQueryString(query2(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "jobs")
+        )
+      );
+    },
+    claim(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      return gateway.request({
+        path: "/api/platform/v1/jobs/claim",
+        method: "POST",
+        body: body2(input, "jobs.claim"),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    updateStatus(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.jobId, "jobId");
+      return gateway.request({
+        path: `/api/platform/v1/jobs/${encodeURIComponent(input.jobId)}/status`,
+        method: "PATCH",
+        body: body2(
+          input,
+          "jobs.updateStatus"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    retry(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.jobId, "jobId");
+      return gateway.request({
+        path: `/api/platform/v1/jobs/${encodeURIComponent(input.jobId)}/retry`,
+        method: "POST",
+        body: body2(input, "jobs.retry"),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    recordRunStart(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      return gateway.request({
+        path: "/api/platform/v1/jobs/runs/start",
+        method: "POST",
+        body: body2(
+          input,
+          "jobs.recordRunStart"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    recordRunFinish(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.runId, "runId");
+      return gateway.request({
+        path: `/api/platform/v1/jobs/runs/${encodeURIComponent(
+          input.runId
+        )}/finish`,
+        method: "POST",
+        body: body2(
+          input,
+          "jobs.recordRunFinish"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
 // src/learningClient.ts
 function createLearningClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
@@ -3571,17 +4810,133 @@ function createLearningClient(config = {}) {
     async getRecentExecutions(args = {}) {
       return this.listRecentExecutions(args);
     },
-    /**
-     * Get aggregate execution statistics.
-     */
-    async getExecutionStats(args = {}) {
+    /**
+     * Get aggregate execution statistics.
+     */
+    async getExecutionStats(args = {}) {
+      return gateway.request({
+        path: `/api/platform/v1/learning/executions/stats${toQueryString({
+          ...normalizeTopicQuery(args),
+          namespace: args.namespace,
+          audienceMode: args.audienceMode,
+          hours: typeof args.hours === "number" && Number.isFinite(args.hours) ? String(args.hours) : void 0
+        })}`
+      });
+    }
+  };
+}
+function toJsonValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const json = JSON.stringify(value, (_key, candidate) => {
+    if (typeof candidate === "bigint") {
+      return candidate.toString();
+    }
+    if (typeof candidate === "function" || typeof candidate === "symbol" || typeof candidate === "undefined") {
+      return void 0;
+    }
+    if (candidate && typeof candidate === "object") {
+      if (seen.has(candidate)) {
+        return "[Circular]";
+      }
+      seen.add(candidate);
+    }
+    return candidate;
+  });
+  if (json === void 0) {
+    return void 0;
+  }
+  return JSON.parse(json);
+}
+function createMcpClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    bootstrapSession(input = {}) {
+      const scope = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId
+      };
+      const body4 = {
+        transportKind: input.transportKind,
+        sessionId: input.sessionId,
+        agentIdentity: input.agentIdentity,
+        workspaceId: input.workspaceId
+      };
+      return gateway.request({
+        path: `${MCP_GATEWAY_BOOTSTRAP_ENDPOINT}${toQueryString(scope)}`,
+        method: "POST",
+        body: body4
+      });
+    },
+    checkWritePolicy(input) {
+      const scope = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId
+      };
+      return gateway.request({
+        path: `${MCP_GATEWAY_WRITE_POLICY_CHECK_ENDPOINT}${toQueryString(scope)}`,
+        method: "POST",
+        body: {
+          topicId: input.topicId,
+          role: input.role,
+          toolName: input.toolName
+        }
+      });
+    },
+    beginBuildSession(input) {
+      const scope = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId
+      };
+      return gateway.request({
+        path: `${MCP_GATEWAY_BEGIN_BUILD_SESSION_ENDPOINT}${toQueryString(scope)}`,
+        method: "POST",
+        body: {
+          worktreeId: input.worktreeId,
+          branch: input.branch,
+          branchBase: input.branchBase,
+          prBase: input.prBase,
+          sessionMode: input.sessionMode,
+          activateIfPlanning: input.activateIfPlanning
+        }
+      });
+    },
+    evaluateEngineeringContract(input) {
+      const scope = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId
+      };
+      return gateway.request({
+        path: `${MCP_GATEWAY_EVALUATE_ENGINEERING_CONTRACT_ENDPOINT}${toQueryString(scope)}`,
+        method: "POST",
+        body: {
+          beliefNodeId: toJsonValue(input.beliefNodeId),
+          trigger: toJsonValue(input.trigger),
+          testOutput: toJsonValue(input.testOutput),
+          tscOutput: toJsonValue(input.tscOutput),
+          lintOutput: toJsonValue(input.lintOutput),
+          sentryData: toJsonValue(input.sentryData)
+        }
+      });
+    },
+    evaluateResearchContract(input) {
+      const scope = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId
+      };
       return gateway.request({
-        path: `/api/platform/v1/learning/executions/stats${toQueryString({
-          ...normalizeTopicQuery(args),
-          namespace: args.namespace,
-          audienceMode: args.audienceMode,
-          hours: typeof args.hours === "number" && Number.isFinite(args.hours) ? String(args.hours) : void 0
-        })}`
+        path: `${MCP_GATEWAY_EVALUATE_RESEARCH_CONTRACT_ENDPOINT}${toQueryString(scope)}`,
+        method: "POST",
+        body: {
+          beliefNodeId: toJsonValue(input.beliefNodeId),
+          trigger: toJsonValue(input.trigger),
+          metricData: toJsonValue(input.metricData),
+          referenceCheckData: toJsonValue(input.referenceCheckData),
+          marketIndexData: toJsonValue(input.marketIndexData),
+          temporalData: toJsonValue(input.temporalData)
+        }
       });
     }
   };
@@ -4068,6 +5423,304 @@ function createFunctionSurfaceClient(config = {}) {
   };
 }
 
+// src/modelRuntimeClient.ts
+var MODEL_RUNTIME_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "principalId",
+  "functionName",
+  "slotKey",
+  "modelId",
+  "provider",
+  "routingPolicy",
+  "metadata",
+  "limit",
+  "cursor"
+];
+function scopeQuery(input) {
+  return {
+    tenantId: cleanRequiredString(input.tenantId, "tenantId"),
+    workspaceId: input.workspaceId,
+    principalId: input.principalId,
+    provider: input.provider,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function modelRuntimeBody(input, operation) {
+  return knownPayload(input, MODEL_RUNTIME_FIELDS, operation);
+}
+function createModelRuntimeClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    listModels(input) {
+      return gateway.request({
+        path: `/api/platform/v1/model-runtime/models${toQueryString(
+          scopeQuery(input)
+        )}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "models")
+        )
+      );
+    },
+    getModel(input) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.modelId, "modelId");
+      return gateway.request({
+        path: `/api/platform/v1/model-runtime/models/${encodeURIComponent(
+          input.modelId
+        )}${toQueryString({
+          tenantId: input.tenantId,
+          workspaceId: input.workspaceId,
+          principalId: input.principalId
+        })}`
+      });
+    },
+    listFunctionSlots(input) {
+      return gateway.request({
+        path: `/api/platform/v1/model-runtime/function-slots${toQueryString({
+          ...scopeQuery(input),
+          functionName: input.functionName
+        })}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "slots")
+        )
+      );
+    },
+    resolveSlot(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.functionName, "functionName");
+      return gateway.request({
+        path: "/api/platform/v1/model-runtime/function-slots/resolve",
+        method: "POST",
+        body: modelRuntimeBody(
+          input,
+          "modelRuntime.resolveSlot"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    updateSlotConfig(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.functionName, "functionName");
+      cleanRequiredString(input.slotKey, "slotKey");
+      cleanRequiredString(input.modelId, "modelId");
+      return gateway.request({
+        path: "/api/platform/v1/model-runtime/slot-configs",
+        method: "PUT",
+        body: modelRuntimeBody(
+          input,
+          "modelRuntime.updateSlotConfig"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
+// src/ontologyLinksClient.ts
+var ONTOLOGY_LINK_FIELDS = [
+  "topicId",
+  "workspaceId",
+  "linkId",
+  "sourceNodeId",
+  "sourceGlobalId",
+  "targetNodeId",
+  "targetGlobalId",
+  "ontologyId",
+  "ontologyType",
+  "edgeType",
+  "weight",
+  "confidence",
+  "status",
+  "metadata"
+];
+function assertEndpoints(input) {
+  if (!input.sourceNodeId && !input.sourceGlobalId) {
+    throw new Error("sourceNodeId or sourceGlobalId is required");
+  }
+  if (!input.targetNodeId && !input.targetGlobalId) {
+    throw new Error("targetNodeId or targetGlobalId is required");
+  }
+}
+function normalizeLinkPayload(input, operation) {
+  assertEndpoints(input);
+  cleanRequiredString(input.ontologyId, "ontologyId");
+  cleanRequiredString(input.edgeType, "edgeType");
+  return knownPayload(input, ONTOLOGY_LINK_FIELDS, operation);
+}
+function createOntologyLinksClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    createLink(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/ontology-links",
+        method: "POST",
+        body: normalizeLinkPayload(input, "ontologyLinks.createLink"),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    upsertLink(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/ontology-links",
+        method: "PUT",
+        body: normalizeLinkPayload(input, "ontologyLinks.upsertLink"),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    listLinksForNode(input) {
+      const nodeId = cleanOptionalString(input.nodeId);
+      const globalId = cleanOptionalString(input.globalId);
+      if (!nodeId && !globalId) {
+        throw new Error("nodeId or globalId is required");
+      }
+      const pathId = encodeURIComponent(nodeId ?? globalId ?? "");
+      return gateway.request({
+        path: `/api/platform/v1/ontology-links/nodes/${pathId}${toQueryString({
+          topicId: input.topicId,
+          workspaceId: input.workspaceId,
+          globalId: nodeId ? void 0 : globalId,
+          ontologyId: input.ontologyId,
+          ontologyType: input.ontologyType,
+          edgeType: input.edgeType,
+          status: input.status,
+          limit: input.limit,
+          cursor: input.cursor
+        })}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "links")
+        )
+      );
+    },
+    updateLinkStatus(input, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/ontology-links/${encodeURIComponent(
+          input.linkId
+        )}/status`,
+        method: "PATCH",
+        body: knownPayload(
+          input,
+          ONTOLOGY_LINK_FIELDS,
+          "ontologyLinks.updateLinkStatus"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
+// src/orgGraphSearchClient.ts
+var ORG_GRAPH_SEARCH_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "query",
+  "nodeTypes",
+  "minConfidence",
+  "limit",
+  "cursor",
+  "provenanceScope"
+];
+function cleanString5(value, label) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required`);
+  }
+  return normalized;
+}
+function assertKnownSearchKeys(input, operation) {
+  const allowed = new Set(ORG_GRAPH_SEARCH_FIELDS);
+  const unknownKeys = Object.keys(input).filter((key) => !allowed.has(key));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `${operation} received unsupported field(s): ${unknownKeys.join(", ")}`
+    );
+  }
+}
+function searchBody(input) {
+  assertKnownSearchKeys(
+    input,
+    "orgGraphSearch.search"
+  );
+  return {
+    tenantId: cleanString5(input.tenantId, "tenantId"),
+    workspaceId: cleanString5(input.workspaceId, "workspaceId"),
+    query: cleanString5(input.query, "query"),
+    nodeTypes: input.nodeTypes,
+    minConfidence: input.minConfidence,
+    limit: input.limit,
+    cursor: input.cursor,
+    provenanceScope: input.provenanceScope
+  };
+}
+function listQuery2(input) {
+  return {
+    tenantId: cleanString5(input.tenantId, "tenantId"),
+    workspaceId: cleanString5(input.workspaceId, "workspaceId"),
+    nodeTypes: input.nodeTypes?.join(","),
+    minConfidence: input.minConfidence,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function mapResults(data) {
+  const record = data && typeof data === "object" ? data : {};
+  return createListResult(
+    Array.isArray(record.results) ? record.results : Array.isArray(data) ? data : [],
+    "results"
+  );
+}
+function createOrgGraphSearchClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    search(input) {
+      return gateway.request({
+        path: "/api/platform/v1/org-graph-search/search",
+        method: "POST",
+        body: searchBody(input)
+      }).then((response) => mapGatewayData(response, mapResults));
+    },
+    getNode(input) {
+      const nodeId = input.nodeId?.trim();
+      const globalId = input.globalId?.trim();
+      if (!nodeId && !globalId) {
+        throw new Error("nodeId or globalId is required");
+      }
+      const nodePath = encodeURIComponent(nodeId ?? globalId ?? "");
+      return gateway.request({
+        path: `/api/platform/v1/org-graph-search/nodes/${nodePath}${toQueryString(
+          {
+            tenantId: cleanString5(input.tenantId, "tenantId"),
+            workspaceId: cleanString5(input.workspaceId, "workspaceId"),
+            globalId: nodeId ? void 0 : globalId
+          }
+        )}`
+      });
+    },
+    listByProvenance(input) {
+      return gateway.request({
+        path: `/api/platform/v1/org-graph-search/provenance${toQueryString({
+          ...listQuery2(input),
+          provenanceScope: input.provenanceScope
+        })}`
+      }).then((response) => mapGatewayData(response, mapResults));
+    },
+    listPublishedFromWorkspace(input) {
+      return gateway.request({
+        path: `/api/platform/v1/org-graph-search/published${toQueryString({
+          ...listQuery2(input),
+          sourceWorkspaceId: input.sourceWorkspaceId
+        })}`
+      }).then((response) => mapGatewayData(response, mapResults));
+    }
+  };
+}
+
 // src/packsClient.ts
 function createPacksClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
@@ -4110,9 +5763,9 @@ function createPacksClient(config = {}) {
     /**
      * List pack states for the current scope.
      */
-    async listStates(query = {}) {
+    async listStates(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/packs/states${toQueryString(query)}`
+        path: `/api/platform/v1/packs/states${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -4123,25 +5776,25 @@ function createPacksClient(config = {}) {
     /**
      * @deprecated Use listStates.
      */
-    async getStates(query = {}) {
-      return this.listStates(query);
+    async getStates(query5 = {}) {
+      return this.listStates(query5);
     },
     /**
      * Get health details for a pack.
      */
-    async getHealth(packKey, query = {}) {
+    async getHealth(packKey, query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/packs/${encodeURIComponent(packKey)}/health${toQueryString(
-          query
+          query5
         )}`
       });
     },
     /**
      * List pack telemetry entries.
      */
-    async listTelemetry(query = {}) {
+    async listTelemetry(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/packs/telemetry${toQueryString(query)}`
+        path: `/api/platform/v1/packs/telemetry${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -4152,8 +5805,8 @@ function createPacksClient(config = {}) {
     /**
      * @deprecated Use listTelemetry.
      */
-    async getTelemetry(query = {}) {
-      return this.listTelemetry(query);
+    async getTelemetry(query5 = {}) {
+      return this.listTelemetry(query5);
     },
     /**
      * Create a pack entitlement.
@@ -4275,9 +5928,9 @@ function createPolicyClient(config = {}) {
     /**
      * List policy decisions in the current scope.
      */
-    async listDecisions(query = {}) {
+    async listDecisions(query5 = {}) {
       return gateway.request({
-        path: `/api/platform/v1/policy/decisions${toQueryString(query)}`
+        path: `/api/platform/v1/policy/decisions${toQueryString(query5)}`
       }).then(
         (response) => mapGatewayData(
           response,
@@ -4310,9 +5963,9 @@ function createPolicyClient(config = {}) {
     /**
      * List write policy rules for the current scope.
      */
-    async listWritePolicies(query = {}) {
+    async listWritePolicies(query5 = {}) {
       const response = await gateway.request({
-        path: `/api/platform/v1/policy/write-policies${toQueryString(query)}`
+        path: `/api/platform/v1/policy/write-policies${toQueryString(query5)}`
       });
       const rawPolicies = response.data && typeof response.data === "object" ? response.data.policies : response.data;
       return {
@@ -4375,9 +6028,9 @@ function createPolicyClient(config = {}) {
     /**
      * List tenant role policies for the current scope.
      */
-    async listRolePolicies(query = {}) {
+    async listRolePolicies(query5 = {}) {
       const response = await gateway.request({
-        path: `/api/platform/v1/policy/roles${toQueryString(query)}`
+        path: `/api/platform/v1/policy/roles${toQueryString(query5)}`
       });
       return {
         ...response,
@@ -4435,28 +6088,28 @@ function createPolicyClient(config = {}) {
     /**
      * Check a permission decision for a topic or project scope.
      */
-    async checkPermission(query) {
-      if (!query.topicId) {
+    async checkPermission(query5) {
+      if (!query5.topicId) {
         throw new Error("topicId is required");
       }
       return gateway.request({
-        path: `/api/platform/v1/policy/check${toQueryString(query)}`
+        path: `/api/platform/v1/policy/check${toQueryString(query5)}`
       });
     },
     /**
      * List accessible topics for a principal.
      */
-    async listAccessibleTopics(query = {}) {
-      const permission = query.permission ?? "read";
-      const principal = query.principal ?? query.principalId;
+    async listAccessibleTopics(query5 = {}) {
+      const permission = query5.permission ?? "read";
+      const principal = query5.principal ?? query5.principalId;
       const response = await gateway.request({
         path: `/api/platform/v1/policy/topics${toQueryString({
-          tenantId: query.tenantId,
-          workspaceId: query.workspaceId,
+          tenantId: query5.tenantId,
+          workspaceId: query5.workspaceId,
           permission,
-          includeShared: query.includeShared,
+          includeShared: query5.includeShared,
           principal,
-          limit: query.limit
+          limit: query5.limit
         })}`
       });
       return {
@@ -4639,6 +6292,294 @@ function createSchemaClient(config = {}) {
   };
 }
 
+// src/telemetryClient.ts
+var TELEMETRY_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "principalId",
+  "topicId",
+  "worktreeId",
+  "eventLevel",
+  "eventType",
+  "message",
+  "toolName",
+  "toolCalls",
+  "decision",
+  "policySubject",
+  "policyAction",
+  "policyResource",
+  "runId",
+  "runType",
+  "status",
+  "durationMs",
+  "error",
+  "metadata",
+  "limit",
+  "cursor"
+];
+function query3(input) {
+  return {
+    tenantId: cleanRequiredString(input.tenantId, "tenantId"),
+    workspaceId: input.workspaceId,
+    principalId: input.principalId,
+    topicId: input.topicId,
+    worktreeId: input.worktreeId,
+    runType: input.runType,
+    status: input.status,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function body3(input, operation) {
+  return knownPayload(input, TELEMETRY_FIELDS, operation);
+}
+function createTelemetryClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    logSystemEvent(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.eventType, "eventType");
+      cleanRequiredString(input.message, "message");
+      return gateway.request({
+        path: "/api/platform/v1/telemetry/system-events",
+        method: "POST",
+        body: body3(
+          input,
+          "telemetry.logSystemEvent"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    logToolCallsBatch(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      return gateway.request({
+        path: "/api/platform/v1/telemetry/tool-calls/batch",
+        method: "POST",
+        body: body3(
+          input,
+          "telemetry.logToolCallsBatch"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    recordEpistemicAudit(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.eventType, "eventType");
+      return gateway.request({
+        path: "/api/platform/v1/telemetry/epistemic-audits",
+        method: "POST",
+        body: body3(
+          input,
+          "telemetry.recordEpistemicAudit"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    recordPolicyDecision(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.decision, "decision");
+      return gateway.request({
+        path: "/api/platform/v1/telemetry/policy-decisions",
+        method: "POST",
+        body: body3(
+          input,
+          "telemetry.recordPolicyDecision"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    startRun(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.runType, "runType");
+      return gateway.request({
+        path: "/api/platform/v1/telemetry/runs/start",
+        method: "POST",
+        body: body3(
+          input,
+          "telemetry.startRun"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    finishRun(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.runId, "runId");
+      return gateway.request({
+        path: `/api/platform/v1/telemetry/runs/${encodeURIComponent(
+          input.runId
+        )}/finish`,
+        method: "POST",
+        body: body3(
+          input,
+          "telemetry.finishRun"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    listRuns(input) {
+      return gateway.request({
+        path: `/api/platform/v1/telemetry/runs${toQueryString(query3(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "runs")
+        )
+      );
+    }
+  };
+}
+
+// src/toolRegistryClient.ts
+var TOOL_REGISTRY_FIELDS = [
+  "tenantId",
+  "workspaceId",
+  "principalId",
+  "toolName",
+  "packKey",
+  "packVersion",
+  "status",
+  "permissions",
+  "role",
+  "surface",
+  "parameterSchema",
+  "returnSchema",
+  "handlerRef",
+  "executionAdapter",
+  "safetyMetadata",
+  "aclId",
+  "metadata",
+  "limit",
+  "cursor"
+];
+function query4(input) {
+  return {
+    tenantId: cleanRequiredString(input.tenantId, "tenantId"),
+    workspaceId: input.workspaceId,
+    principalId: input.principalId,
+    packKey: input.packKey,
+    status: input.status,
+    limit: input.limit,
+    cursor: input.cursor
+  };
+}
+function writeBody(input, operation) {
+  return knownPayload(input, TOOL_REGISTRY_FIELDS, operation);
+}
+function createToolRegistryClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    listCatalog(input) {
+      return gateway.request({
+        path: `/api/platform/v1/tools/catalog${toQueryString(query4(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "tools")
+        )
+      );
+    },
+    listExecutable(input) {
+      return gateway.request({
+        path: `/api/platform/v1/tools/executable${toQueryString(query4(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "tools")
+        )
+      );
+    },
+    listEffectiveTools(input) {
+      return gateway.request({
+        path: `/api/platform/v1/tools/effective${toQueryString(query4(input))}`
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "tools")
+        )
+      );
+    },
+    upsertCoreTools(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      return gateway.request({
+        path: "/api/platform/v1/tools/core",
+        method: "PUT",
+        body: {
+          tenantId: input.tenantId,
+          workspaceId: input.workspaceId,
+          metadata: input.metadata,
+          tools: input.tools
+        },
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "tools")
+        )
+      );
+    },
+    setPackToolsStatus(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.packKey, "packKey");
+      return gateway.request({
+        path: `/api/platform/v1/tools/packs/${encodeURIComponent(
+          input.packKey
+        )}/status`,
+        method: "PATCH",
+        body: writeBody(
+          input,
+          "tools.setPackToolsStatus"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(
+        (response) => mapGatewayData(
+          response,
+          (data) => listResultFromEnvelope(data, "tools")
+        )
+      );
+    },
+    createAcl(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.principalId, "principalId");
+      cleanRequiredString(input.toolName, "toolName");
+      return gateway.request({
+        path: "/api/platform/v1/tools/acls",
+        method: "POST",
+        body: writeBody(
+          input,
+          "tools.createAcl"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    deleteAcl(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.aclId, "aclId");
+      return gateway.request({
+        path: `/api/platform/v1/tools/acls/${encodeURIComponent(input.aclId)}`,
+        method: "DELETE",
+        body: writeBody(
+          input,
+          "tools.deleteAcl"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    registerCustomTool(input, idempotencyKey) {
+      cleanRequiredString(input.tenantId, "tenantId");
+      cleanRequiredString(input.toolName, "toolName");
+      return gateway.request({
+        path: "/api/platform/v1/tools/custom",
+        method: "POST",
+        body: writeBody(
+          input,
+          "tools.registerCustomTool"
+        ),
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
+
 // src/version.ts
 var LUCERN_SDK_VERSION = "0.2.0-alpha.1";
 
@@ -4656,10 +6597,10 @@ function createWorkflowClient(config = {}) {
     /**
      * List workflow branches for a topic scope.
      */
-    async listBranches(query) {
+    async listBranches(query5) {
       return gateway.request({
         path: `/api/platform/v1/workflow/branches${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       }).then(
         (response) => mapGatewayData(
@@ -4687,10 +6628,10 @@ function createWorkflowClient(config = {}) {
     /**
      * List reusable lenses for a workspace or topic scope.
      */
-    async listLenses(query) {
+    async listLenses(query5) {
       return gateway.request({
         path: `/api/platform/v1/workflow/lenses${toQueryString(
-          normalizeLensQuery(query)
+          normalizeLensQuery(query5)
         )}`
       }).then(
         (response) => mapGatewayData(
@@ -4762,14 +6703,14 @@ function createWorkflowClient(config = {}) {
     /**
      * List worktrees for a topic scope.
      */
-    async listWorktrees(query) {
-      const normalized = normalizeTopicQuery(query);
+    async listWorktrees(query5) {
+      const normalized = normalizeTopicQuery(query5);
       return gateway.request({
         path: `/api/platform/v1/worktrees/all${toQueryString({
           ...normalized,
-          groupBy: query.groupBy,
-          lane: query.lane,
-          campaign: query.campaign
+          groupBy: query5.groupBy,
+          lane: query5.lane,
+          campaign: query5.campaign
         })}`
       }).then(
         (response) => mapGatewayData(
@@ -4784,14 +6725,14 @@ function createWorkflowClient(config = {}) {
     /**
      * List all worktrees across accessible topics.
      */
-    async listAllWorktrees(query = {}) {
+    async listAllWorktrees(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/worktrees${toQueryString({
-          status: query.status,
-          groupBy: query.groupBy,
-          lane: query.lane,
-          campaign: query.campaign,
-          limit: query.limit
+          status: query5.status,
+          groupBy: query5.groupBy,
+          lane: query5.lane,
+          campaign: query5.campaign,
+          limit: query5.limit
         })}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
@@ -4811,10 +6752,10 @@ function createWorkflowClient(config = {}) {
     /**
      * List compact pipeline campaigns with nested lanes.
      */
-    async listCampaigns(query = {}) {
+    async listCampaigns(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/worktrees/campaigns${toQueryString(
-          normalizeTopicQuery(query)
+          normalizeTopicQuery(query5)
         )}`
       });
     },
@@ -4870,11 +6811,11 @@ function createWorkflowClient(config = {}) {
      * Update targeted beliefs/questions for a worktree.
      */
     async updateWorktreeTargets(input, idempotencyKey) {
-      const { worktreeId, ...body } = input;
+      const { worktreeId, ...body4 } = input;
       return gateway.request({
         path: `/api/platform/v1/worktrees/${encodeURIComponent(worktreeId)}/targets`,
         method: "POST",
-        body,
+        body: body4,
         idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
       }).then(
         (response) => mapGatewayData(
@@ -4963,11 +6904,11 @@ function createWorkflowClient(config = {}) {
     /**
      * List accessible topic contexts.
      */
-    async listTopics(query = {}) {
+    async listTopics(query5 = {}) {
       return gateway.request({
         path: `/api/platform/v1/workflow/topics${toQueryString({
-          includeShared: typeof query.includeShared === "boolean" ? query.includeShared ? "true" : "false" : void 0,
-          limit: query.limit
+          includeShared: typeof query5.includeShared === "boolean" ? query5.includeShared ? "true" : "false" : void 0,
+          limit: query5.limit
         })}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
@@ -5095,13 +7036,15 @@ function toGatewayConfig(config) {
     requestIdFactory: config.requestIdFactory,
     onRequest: config.onRequest,
     onResponse: config.onResponse,
+    authContext: config.authContext,
+    requireCanonicalAuthContext: config.requireCanonicalAuthContext,
     getAuthHeaders: async () => {
       const base = config.getAuthHeaders ? await config.getAuthHeaders() : {};
       if (config.apiKey && !base["x-lucern-key"] && !base.Authorization) {
         base["x-lucern-key"] = config.apiKey;
       }
-      if (config.userToken && !base["x-lucern-user-token"]) {
-        base["x-lucern-user-token"] = config.userToken;
+      if (config.userToken && !base["x-lucern-session-token"]) {
+        base["x-lucern-session-token"] = config.userToken;
       }
       if (config.environment && !base["x-lucern-environment"]) {
         base["x-lucern-environment"] = config.environment;
@@ -5110,7 +7053,7 @@ function toGatewayConfig(config) {
     }
   };
 }
-function requireTopicId(args) {
+function requireTopicId4(args) {
   const topicId = resolveTopicId(args);
   if (!topicId) {
     throw new Error("topicId is required");
@@ -5158,12 +7101,18 @@ function createLucernClient(config = {}) {
   const sourcesClient = createSourcesClient(gatewayConfig);
   const beliefsFacade = createBeliefsFacade(gatewayConfig);
   const evidenceClient = createEvidenceClient(gatewayConfig);
+  const embeddingsClient = createEmbeddingsClient(gatewayConfig);
+  const eventingClient = createEventingClient(gatewayConfig);
   const graphClient = createGraphClient(gatewayConfig);
+  const graphAnalysisClient = createGraphAnalysisClient(gatewayConfig);
+  const graphRecommendationsClient = createGraphRecommendationsClient(gatewayConfig);
+  const graphStateClassifierClient = createGraphStateClassifierClient(gatewayConfig);
   const graphFacade = createGraphFacade(gatewayConfig);
   const decisionsClient = createDecisionsClient(gatewayConfig);
   const contextClient = createContextClient(gatewayConfig);
   const workflowClient = createWorkflowClient(gatewayConfig);
   const auditClient = createAuditClient(gatewayConfig);
+  const authDeviceClient = createAuthDeviceClient(gatewayConfig);
   const adminClient = createAdminClient(gatewayConfig);
   const answersClient = createAnswersClient(gatewayConfig);
   const contradictionsFacade = createContradictionsFacade(gatewayConfig);
@@ -5181,10 +7130,17 @@ function createLucernClient(config = {}) {
   const worktreesFacade = createWorktreesFacade(gatewayConfig);
   const policyClient = createPolicyClient(gatewayConfig);
   const ontologyClient = createOntologyClient(gatewayConfig);
+  const ontologyLinksClient = createOntologyLinksClient(gatewayConfig);
+  const orgGraphSearchClient = createOrgGraphSearchClient(gatewayConfig);
   const functionSurfaceClient = createFunctionSurfaceClient(gatewayConfig);
+  const toolRegistryClient = createToolRegistryClient(gatewayConfig);
+  const modelRuntimeClient = createModelRuntimeClient(gatewayConfig);
   const packsClient = createPacksClient(gatewayConfig);
   const reportsClient = createReportsClient(gatewayConfig);
   const learningClient = createLearningClient(gatewayConfig);
+  const mcpClient = createMcpClient(gatewayConfig);
+  const jobsClient = createJobsClient(gatewayConfig);
+  const telemetryClient = createTelemetryClient(gatewayConfig);
   const harnessClient = createHarnessClient(gatewayConfig);
   const schemaClient = createSchemaClient(gatewayConfig);
   const audiencesClient = createAudiencesClient(gatewayConfig);
@@ -5313,7 +7269,7 @@ function createLucernClient(config = {}) {
   }
   async function listBeliefs(args) {
     const response = await beliefsFacade.list({
-      topicId: requireTopicId(args),
+      topicId: requireTopicId4(args),
       status: args.status,
       worktreeId: args.worktreeId,
       minConfidence: args.minConfidence,
@@ -5341,13 +7297,13 @@ function createLucernClient(config = {}) {
     const results = groupedBeliefs.length > 0 ? groupedBeliefs : mergedResults.filter((result) => result.type === "belief");
     return { results };
   }
-  async function searchResources(query, options = {}) {
+  async function searchResources(query5, options = {}) {
     const topicId = resolveTopicId(options);
     if (!topicId) {
       throw new Error("topicId is required");
     }
     return searchFacade.query({
-      q: query,
+      q: query5,
       topicId,
       types: options.types,
       status: options.status,
@@ -5542,8 +7498,8 @@ function createLucernClient(config = {}) {
     }).then(exposeGatewayData);
   }
   const nodesNamespace = {
-    list(query) {
-      return graphClient.listNodes(query);
+    list(query5) {
+      return graphClient.listNodes(query5);
     },
     get(input) {
       return graphClient.getNode(
@@ -5572,16 +7528,22 @@ function createLucernClient(config = {}) {
   return {
     config,
     version: LUCERN_SDK_VERSION,
-    search(query, options) {
-      return searchResources(query, options);
+    search(query5, options) {
+      return searchResources(query5, options);
     },
     events: {
-      list(query = {}) {
-        return eventsFacade.list(query).then(exposeGatewayData);
+      list(query5 = {}) {
+        return eventsFacade.list(query5).then(exposeGatewayData);
       },
       replay(input) {
         return eventsFacade.replay(input).then(exposeGatewayData);
-      }
+      },
+      recordEvent: eventingClient.recordEvent,
+      listEvents: eventingClient.listEvents,
+      listWebhooks: eventingClient.listWebhooks,
+      enqueueDelivery: eventingClient.enqueueDelivery,
+      recordDeliveryAttempt: eventingClient.recordDeliveryAttempt,
+      updateDeliveryStatus: eventingClient.updateDeliveryStatus
     },
     beliefs: {
       create(input) {
@@ -5650,7 +7612,7 @@ function createLucernClient(config = {}) {
       },
       list(args) {
         return beliefsFacade.list({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           worktreeId: args.worktreeId,
           status: args.status,
           minConfidence: args.minConfidence,
@@ -5679,8 +7641,8 @@ function createLucernClient(config = {}) {
       create(input) {
         return webhooksFacade.create(input).then(exposeGatewayData);
       },
-      list(query) {
-        return webhooksFacade.list(query).then(exposeGatewayData);
+      list(query5) {
+        return webhooksFacade.list(query5).then(exposeGatewayData);
       },
       get(id) {
         return webhooksFacade.get(id).then(exposeGatewayData);
@@ -5694,8 +7656,8 @@ function createLucernClient(config = {}) {
       test(id, input) {
         return webhooksFacade.test(id, input).then(exposeGatewayData);
       },
-      deliveries(id, query) {
-        return webhooksFacade.deliveries(id, query).then(exposeGatewayData);
+      deliveries(id, query5) {
+        return webhooksFacade.deliveries(id, query5).then(exposeGatewayData);
       },
       health(id) {
         return webhooksFacade.health(id).then(exposeGatewayData);
@@ -5850,7 +7812,7 @@ function createLucernClient(config = {}) {
       },
       list(args) {
         return questionsFacade.list({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           status: args.status,
           priority: args.priority,
           worktreeId: args.worktreeId,
@@ -5922,7 +7884,7 @@ function createLucernClient(config = {}) {
       },
       getHighPriority(args) {
         return this.list({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           status: args.includeAnswered ? void 0 : "open"
         }).then((data) => {
           const questions = Array.isArray(data.questions) ? data.questions : [];
@@ -5947,7 +7909,7 @@ function createLucernClient(config = {}) {
       },
       async findMissing(args) {
         return graphFacade.gaps({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           minConfidence: args.minConfidence
         }).then(exposeGatewayData);
       }
@@ -5978,21 +7940,21 @@ function createLucernClient(config = {}) {
       },
       analyze(args) {
         return graphFacade.analyze({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           limit: args.limit,
           metric: args.metric
         }).then(exposeGatewayData);
       },
       bias(args) {
         return graphFacade.bias({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           threshold: args.threshold,
           limit: args.limit
         }).then(exposeGatewayData);
       },
       gaps(args) {
         return graphFacade.gaps({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           minConfidence: args.minConfidence
         }).then(exposeGatewayData);
       },
@@ -6051,8 +8013,8 @@ function createLucernClient(config = {}) {
       record(input) {
         return decisionsClient.recordJudgment(input);
       },
-      list(query) {
-        return decisionsClient.listJudgments(query);
+      list(query5) {
+        return decisionsClient.listJudgments(query5);
       },
       get(judgmentId) {
         return decisionsClient.getJudgment(judgmentId);
@@ -6081,7 +8043,7 @@ function createLucernClient(config = {}) {
       transitionAuditIntegrity(args) {
         return decisionsClient.getJudgmentTransitionAuditIntegrity({
           ...args,
-          topicId: requireTopicId(args)
+          topicId: requireTopicId4(args)
         });
       }
     },
@@ -6092,8 +8054,8 @@ function createLucernClient(config = {}) {
       createLens(input) {
         return workflowClient.createLens(input);
       },
-      listLenses(query) {
-        return workflowClient.listLenses(query);
+      listLenses(query5) {
+        return workflowClient.listLenses(query5);
       },
       applyLensToTopic(input) {
         return workflowClient.applyLensToTopic(input);
@@ -6104,7 +8066,7 @@ function createLucernClient(config = {}) {
       create(input) {
         return worktreesFacade.create({
           title: input.title,
-          topicId: requireTopicId(input),
+          topicId: requireTopicId4(input),
           objective: input.objective,
           hypothesis: input.hypothesis,
           beliefIds: input.beliefIds,
@@ -6126,7 +8088,7 @@ function createLucernClient(config = {}) {
       add(input) {
         return worktreesFacade.create({
           title: input.title,
-          topicId: requireTopicId(input),
+          topicId: requireTopicId4(input),
           objective: input.objective,
           hypothesis: input.hypothesis,
           beliefIds: input.beliefIds,
@@ -6145,11 +8107,11 @@ function createLucernClient(config = {}) {
           autoFixPolicy: input.autoFixPolicy
         });
       },
-      list(query) {
+      list(query5) {
         return worktreesFacade.list({
-          topicId: requireTopicId(query),
-          status: query.status,
-          limit: query.limit
+          topicId: requireTopicId4(query5),
+          status: query5.status,
+          limit: query5.limit
         });
       },
       activate(worktreeId) {
@@ -6184,8 +8146,8 @@ function createLucernClient(config = {}) {
           removeQuestionIds: input.removeQuestionIds
         });
       },
-      listAll(query = {}) {
-        return workflowClient.listAllWorktrees(query);
+      listAll(query5 = {}) {
+        return workflowClient.listAllWorktrees(query5);
       },
       merge(worktreeId, input) {
         return worktreesFacade.merge({
@@ -6226,12 +8188,12 @@ function createLucernClient(config = {}) {
       }
     },
     context: {
-      listTopics(query = {}) {
+      listTopics(query5 = {}) {
         return topicsFacade.list({
-          ontologyId: query.ontologyId,
-          parentTopicId: query.parentTopicId,
-          status: query.status,
-          type: query.type
+          ontologyId: query5.ontologyId,
+          parentTopicId: query5.parentTopicId,
+          status: query5.status,
+          type: query5.type
         });
       },
       compile(topicId, input = {}) {
@@ -6342,10 +8304,10 @@ function createLucernClient(config = {}) {
           visibility: input.visibility
         });
       },
-      tree(topicId, query = {}) {
+      tree(topicId, query5 = {}) {
         return topicsFacade.tree({
           id: topicId,
-          maxDepth: query.maxDepth
+          maxDepth: query5.maxDepth
         });
       },
       getTree(input) {
@@ -6354,11 +8316,11 @@ function createLucernClient(config = {}) {
           maxDepth: input.maxDepth
         });
       },
-      coverage(topicId, query = {}) {
+      coverage(topicId, query5 = {}) {
         return topicsFacade.coverage({
           id: topicId,
-          includeDescendants: query.includeDescendants,
-          maxDepth: query.maxDepth
+          includeDescendants: query5.includeDescendants,
+          maxDepth: query5.maxDepth
         });
       },
       remove(topicId, idempotencyKey) {
@@ -6408,7 +8370,7 @@ function createLucernClient(config = {}) {
       },
       list(args) {
         return contradictionsFacade.list({
-          topicId: requireTopicId(args),
+          topicId: requireTopicId4(args),
           status: args.status,
           limit: args.limit,
           cursor: args.cursor
@@ -6583,7 +8545,24 @@ function createLucernClient(config = {}) {
         return functionSurfaceClient.generateSessionHandoff(input);
       }
     },
+    embeddings: embeddingsClient,
+    graphAnalysis: graphAnalysisClient,
+    graphRecommendations: graphRecommendationsClient,
+    orgGraphSearch: orgGraphSearchClient,
+    ontologyLinks: ontologyLinksClient,
+    graphStateClassifier: graphStateClassifierClient,
+    modelRuntime: modelRuntimeClient,
+    jobs: jobsClient,
+    telemetry: telemetryClient,
     tools: {
+      listCatalog: toolRegistryClient.listCatalog,
+      listExecutable: toolRegistryClient.listExecutable,
+      listEffectiveTools: toolRegistryClient.listEffectiveTools,
+      upsertCoreTools: toolRegistryClient.upsertCoreTools,
+      setPackToolsStatus: toolRegistryClient.setPackToolsStatus,
+      createAcl: toolRegistryClient.createAcl,
+      deleteAcl: toolRegistryClient.deleteAcl,
+      registerCustomTool: toolRegistryClient.registerCustomTool,
       register(registration) {
         return registerCustomTool(registration);
       },
@@ -6640,26 +8619,74 @@ function createLucernClient(config = {}) {
       }
     },
     nodes: nodesNamespace,
-    identity: identityFacade,
+    identity: {
+      ...identityFacade,
+      evaluatePolicy: identityClient.evaluatePolicy,
+      recordPolicyDecision: identityClient.recordPolicyDecision,
+      putSecretReference: identityClient.putSecretReference,
+      createPrincipal: identityClient.createPrincipal,
+      updatePrincipal: identityClient.updatePrincipal,
+      raw: identityClient
+    },
+    mcp: {
+      bootstrapSession(input) {
+        return mcpClient.bootstrapSession(input);
+      },
+      checkWritePolicy(input) {
+        return mcpClient.checkWritePolicy(input);
+      },
+      beginBuildSession(input) {
+        return mcpClient.beginBuildSession(input);
+      },
+      evaluateEngineeringContract(input) {
+        return mcpClient.evaluateEngineeringContract(input);
+      },
+      evaluateResearchContract(input) {
+        return mcpClient.evaluateResearchContract(input);
+      }
+    },
+    auth: {
+      device: {
+        createCode(input) {
+          return authDeviceClient.createDeviceCode(input);
+        },
+        pollToken(deviceCode) {
+          return authDeviceClient.pollDeviceToken(deviceCode);
+        }
+      }
+    },
     custom: getCustomNamespace("custom"),
     extensions: extensionNamespaces,
     raw: {
       beliefs: beliefsClient,
       sources: sourcesClient,
       evidence: evidenceClient,
+      embeddings: embeddingsClient,
+      eventing: eventingClient,
       graph: graphClient,
+      graphAnalysis: graphAnalysisClient,
+      graphRecommendations: graphRecommendationsClient,
+      graphStateClassifier: graphStateClassifierClient,
       decisions: decisionsClient,
       workflow: workflowClient,
       audit: auditClient,
+      authDevice: authDeviceClient,
       admin: adminClient,
       identity: identityClient,
       policy: policyClient,
       answers: answersClient,
       ontology: ontologyClient,
+      ontologyLinks: ontologyLinksClient,
+      orgGraphSearch: orgGraphSearchClient,
       functionSurface: functionSurfaceClient,
+      toolRegistry: toolRegistryClient,
+      modelRuntime: modelRuntimeClient,
       packs: packsClient,
       reports: reportsClient,
       learning: learningClient,
+      mcp: mcpClient,
+      jobs: jobsClient,
+      telemetry: telemetryClient,
       harness: harnessClient,
       schema: schemaClient,
       audiences: audiencesClient,