@opengeni/contracts 0.44.1 → 1.0.0

package/src/skill-catalog-context.ts

@@ -0,0 +1,50 @@
+/** Durable, model-visible catalog context. Text markers survive SDK/provider replay. */
+export const SKILL_CATALOG_CONTEXT_PREFIX = "<opengeni_skill_catalog>\n";
+export const SKILL_CATALOG_CONTEXT_SUFFIX = "\n</opengeni_skill_catalog>";
+const GUIDANCE =
+  "This is the current configured Skill index and replaces earlier configured Skill indexes. " +
+  "Entries describe discoverability, not permission or full instructions. " +
+  "Use skill_read for instructions and skill_search for current discovery; tool authorization remains authoritative.\n\n";
+
+export function skillCatalogContextItem(catalog: string): Record<string, unknown> {
+  return {
+    type: "message",
+    role: "developer",
+    content: SKILL_CATALOG_CONTEXT_PREFIX + GUIDANCE + catalog + SKILL_CATALOG_CONTEXT_SUFFIX,
+  };
+}
+
+/** Accept the Chat Completions projection and SDK text-part normalization too. */
+export function readSkillCatalogContext(item: Record<string, unknown>): string | null {
+  if (item.type === "unknown" && item.providerData && typeof item.providerData === "object") {
+    const data = item.providerData as Record<string, unknown>;
+    if (data.type === "message") return readSkillCatalogContext(data);
+  }
+  if (item.type !== "message" || (item.role !== "developer" && item.role !== "system")) return null;
+  const content =
+    typeof item.content === "string"
+      ? item.content
+      : Array.isArray(item.content) &&
+          item.content.every(
+            (part) =>
+              part &&
+              (part.type === "input_text" || part.type === "output_text" || part.type === "text") &&
+              typeof part.text === "string",
+          )
+        ? item.content.map((part) => part.text).join("")
+        : null;
+  const prefix = SKILL_CATALOG_CONTEXT_PREFIX + GUIDANCE;
+  return content?.startsWith(prefix) && content.endsWith(SKILL_CATALOG_CONTEXT_SUFFIX)
+    ? content.slice(prefix.length, -SKILL_CATALOG_CONTEXT_SUFFIX.length)
+    : null;
+}
+
+export function latestSkillCatalogContext(
+  items: readonly Record<string, unknown>[],
+): Record<string, unknown> | undefined {
+  for (let index = items.length - 1; index >= 0; index--) {
+    const catalog = readSkillCatalogContext(items[index]!);
+    if (catalog !== null) return skillCatalogContextItem(catalog);
+  }
+  return undefined;
+}

package/src/skill-files.ts

@@ -0,0 +1,52 @@
+/** Shared text-folder limits for API admission, runtime imports and checkout. */
+export const SKILL_MAX_FILES = 1024;
+export const SKILL_MAX_FILE_BYTES = 2 * 1024 * 1024;
+export const SKILL_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+
+export function isSafeSkillRelativePath(path: string): boolean {
+  return (
+    path.length > 0 &&
+    path.length <= 512 &&
+    !/[\\:\u0000-\u001f\u007f]/u.test(path) &&
+    path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..") &&
+    new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+      new TextEncoder().encode(path),
+    ) === path
+  );
+}
+
+/** Validates bytes, not extensions. Does not rewrite text or interpret metadata. */
+export function validateSkillTextFiles(files: readonly { path: string; content: string }[]): {
+  totalBytes: number;
+} {
+  if (files.length === 0 || files.length > SKILL_MAX_FILES)
+    throw new Error(`Skill artifact must contain 1-${SKILL_MAX_FILES} files`);
+  const paths = new Set<string>();
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  let totalBytes = 0;
+  for (const { path, content } of files) {
+    if (!isSafeSkillRelativePath(path))
+      throw new Error(`Skill artifact contains an unsafe path: ${path}`);
+    if (paths.has(path)) throw new Error(`Skill artifact contains duplicate file path: ${path}`);
+    paths.add(path);
+    if (content.includes("\u0000")) throw new Error(`Skill artifact contains NUL bytes: ${path}`);
+    const bytes = encoder.encode(content);
+    if (decoder.decode(bytes) !== content)
+      throw new Error(`Skill artifact contains malformed Unicode text: ${path}`);
+    if (bytes.byteLength > SKILL_MAX_FILE_BYTES)
+      throw new Error(`Skill artifact file exceeds ${SKILL_MAX_FILE_BYTES} bytes: ${path}`);
+    totalBytes += bytes.byteLength;
+    if (totalBytes > SKILL_MAX_TOTAL_BYTES)
+      throw new Error(`Skill artifact exceeds ${SKILL_MAX_TOTAL_BYTES} bytes`);
+  }
+  for (const path of paths) {
+    const segments = path.split("/");
+    for (let index = 1; index < segments.length; index++) {
+      const prefix = segments.slice(0, index).join("/");
+      if (paths.has(prefix))
+        throw new Error(`Skill artifact uses a path as both a file and a directory: ${prefix}`);
+    }
+  }
+  return { totalBytes };
+}

package/src/skill-metadata.ts

@@ -0,0 +1,40 @@
+import { parseDocument } from "yaml";
+
+/** The one interpretation of Skill metadata for imports, writes and migration. */
+export function parseSkillFrontmatter(markdown: string): {
+  name: string | null;
+  description: string | null;
+} {
+  const lines = markdown.split(/\r?\n/u);
+  if (lines[0]?.trim() !== "---") return { name: null, description: null };
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  if (end === -1) return { name: null, description: null };
+  const document = parseDocument(lines.slice(1, end).join("\n"), {
+    schema: "core",
+    uniqueKeys: true,
+    prettyErrors: false,
+  });
+  if (document.errors.length || document.warnings.length) {
+    const issue = document.errors[0] ?? document.warnings[0]!;
+    throw new Error(
+      `This skill's SKILL.md header contains invalid YAML: ${issue.message}. The source file needs correcting.`,
+    );
+  }
+  const metadata: unknown = document.toJS({ maxAliasCount: 20 });
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    throw new Error("Skill artifact SKILL.md frontmatter must be a mapping");
+  const fields = metadata as Record<string, unknown>;
+  return {
+    name: typeof fields.name === "string" ? fields.name : null,
+    description: typeof fields.description === "string" ? fields.description : null,
+  };
+}
+
+export function readSkillMetadata(markdown: string): { name: string; description: string } {
+  const { name, description } = parseSkillFrontmatter(markdown);
+  if (!name || name.length > 64 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name))
+    throw new Error("Skill artifact SKILL.md must declare a safe name");
+  if (!description?.trim() || description.length > 1024)
+    throw new Error("Skill artifact SKILL.md must declare a description of 1–1024 characters");
+  return { name, description };
+}

package/src/skill-use.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+
+/**
+ * `_meta` key of the content-free Skill-use fact on a model `skill_read`
+ * result. MCP `_meta` never reaches the model: it survives only into the
+ * `agent.toolCall.output` event projection, never into model history.
+ */
+export const SKILL_USE_META_KEY = "opengeni/skillUse" as const;
+
+/** Where the Skill a read resolved to comes from. `personal` is a user-scope Skill. */
+export const SkillUseSource = z.enum([
+  "builtin",
+  "session",
+  "workspace",
+  "organization",
+  "personal",
+]);
+export type SkillUseSource = z.infer<typeof SkillUseSource>;
+
+/**
+ * What a `skill_read` returned: `full` is the default SKILL.md read, `files`
+ * explicit paths, `list` a path inventory, and `already_in_context` the short
+ * repeat receipt. `refused` means the read returned an error instead of Skill
+ * text; it has no result, so it appears only in metrics.
+ */
+export const SkillReadKind = z.enum(["full", "already_in_context", "files", "list", "refused"]);
+export type SkillReadKind = z.infer<typeof SkillReadKind>;
+
+const skillUseFields = {
+  id: z.string().min(1).max(512),
+  source: SkillUseSource,
+  label: z.string().min(1).max(128).optional(),
+  /** Whole-artifact digest, for a Skill without a ledger revision. */
+  contentSha256: z
+    .string()
+    .regex(/^[0-9a-f]{64}$/u)
+    .optional(),
+  /** Ledger revision of a workspace, organization, or personal Skill. */
+  revisionId: z.string().min(1).max(128).optional(),
+  kind: SkillReadKind.exclude(["refused"]),
+  /** UTF-8 bytes of the result text the read returned, before model tool-output truncation. */
+  bytes: z.number().int().nonnegative(),
+  /** The Skill appeared in the Skill index the model saw this turn. */
+  inIndex: z.boolean(),
+  /** skill_search returned this Skill earlier in the same turn attempt. */
+  searchedThisTurn: z.boolean(),
+};
+const oneProvenance = (use: {
+  contentSha256?: string | undefined;
+  revisionId?: string | undefined;
+}) => use.contentSha256 === undefined || use.revisionId === undefined;
+const oneProvenanceMessage = {
+  message: "A Skill use carries a content digest or a revision, not both",
+};
+
+/**
+ * Ids, digests, and counts only. Never Skill text, user text, or a Skill's
+ * title or description. `label` is reserved for a platform display label of a
+ * built-in; user-authored Skills never set it. This is the writer's closed
+ * shape: an unknown field fails the parse, so nothing else can be attached.
+ */
+export const SkillUse = z.strictObject(skillUseFields).refine(oneProvenance, oneProvenanceMessage);
+export type SkillUse = z.infer<typeof SkillUse>;
+
+// Stored events outlive the worker that wrote them. A reader drops fields a
+// newer writer added instead of dropping the whole fact, and what it returns
+// still holds only the known, content-free fields.
+const StoredSkillUse = z.object(skillUseFields).refine(oneProvenance, oneProvenanceMessage);
+
+/** The Skill-use fact on a tool result or its event projection, when present and valid. */
+export function skillUseFromToolOutput(output: unknown): SkillUse | null {
+  if (!output || typeof output !== "object" || Array.isArray(output)) return null;
+  const meta = (output as { _meta?: unknown })._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return null;
+  const parsed = StoredSkillUse.safeParse((meta as Record<string, unknown>)[SKILL_USE_META_KEY]);
+  return parsed.success ? parsed.data : null;
+}

package/src/skills.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+export { parseSkillFrontmatter, readSkillMetadata } from "./skill-metadata";
+export * from "./skill-files";
+
+/** Files are UTF-8 text, relative to the Skill root. No executable authority. */
+export const SkillFile = z.object({ path: z.string().min(1).max(512), content: z.string() });
+export type SkillFile = z.infer<typeof SkillFile>;
+export const SkillActor = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("service"),
+    subjectId: z.string().min(1),
+    principalKind: z.enum(["service", "api_key", "configured_key"]),
+  }),
+  z.object({
+    kind: z.literal("human"),
+    subjectId: z.string().min(1),
+    principalKind: z.literal("human_session"),
+  }),
+  z.object({
+    kind: z.literal("agent"),
+    sessionId: z.uuid(),
+    turnId: z.uuid(),
+    attemptId: z.uuid(),
+    executionGeneration: z.number().int().positive(),
+  }),
+]);
+export type SkillActor = z.infer<typeof SkillActor>;
+export type SkillScope = "workspace" | "organization" | "user";
+export type SkillWriteContext = { accountId: string; workspaceId: string; actor: SkillActor };
+export type SkillSaveInput = SkillWriteContext & {
+  operationId: string;
+  skillId: string;
+  expectedRevisionId: string | null;
+  expectedScopeVersion: number;
+  stableKey: string;
+  files: SkillFile[];
+  scope?: SkillScope;
+  reason: string;
+};
+export type SkillRevisionInput = SkillWriteContext & {
+  removalOperationId?: string | undefined;
+  operationId: string;
+  skillId: string;
+  revisionId: string;
+  expectedRevisionId: string | null;
+  expectedScopeVersion: number;
+  reason: string;
+};
+export type SkillRemoveInput = SkillWriteContext & {
+  operationId: string;
+  skillId: string;
+  expectedRevisionId: string | null;
+  expectedScopeVersion: number;
+  reason: string;
+};
+export type SkillInstallInput = SkillWriteContext & {
+  operationId: string;
+  skillFacetId: string;
+  reason: string;
+};
+export const SkillReviewReference = z.object({
+  removalOperationId: z.uuid().optional(),
+  sourceOperationId: z.uuid(),
+  skillId: z.uuid(),
+  revisionId: z.uuid(),
+  expectedRevisionId: z.uuid().nullable(),
+  expectedScopeVersion: z.number().int().positive(),
+});
+export type SkillReviewReference = z.infer<typeof SkillReviewReference>;
+export function skillReviewHumanInput(skillReview: SkillReviewReference) {
+  const removing = Boolean(skillReview.removalOperationId);
+  return {
+    questions: [
+      {
+        id: `skill:${skillReview.revisionId}`,
+        kind: "single_select" as const,
+        label: removing ? "Permanently delete this Skill?" : "Save this Skill?",
+        prompt: removing
+          ? "Permanently delete this Skill and all its stored revisions?"
+          : "Save this exact Skill revision for this workspace?",
+        helpText: removing
+          ? "This cannot be undone. All stored Skill revisions will be deleted; conversations remain unchanged."
+          : "Review the complete files before saving. Saving activates this revision immediately.",
+        options: [
+          { id: "save", label: removing ? "Permanently delete" : "Save" },
+          { id: "skip", label: removing ? "Keep Skill" : "Don't save" },
+        ],
+        required: true,
+        allowOther: false,
+        skillReview,
+      },
+    ],
+  };
+}
+export const SkillWriteReceipt = z.object({
+  removed: z.boolean().optional(),
+  operationId: z.uuid(),
+  skillId: z.uuid(),
+  revisionId: z.uuid(),
+  outcome: z.enum(["applied", "pending", "preserved"]),
+  decision: z.literal("rejected").optional(),
+  pendingReason: z.enum(["approval", "source_finalization"]).optional(),
+  skillReview: SkillReviewReference.optional(),
+  replayed: z.boolean(),
+});
+export type SkillWriteReceipt = z.infer<typeof SkillWriteReceipt>;
+export const SkillPublicationReceipt = SkillWriteReceipt.extend({
+  sourceOperationId: z.uuid(),
+  activationEventId: z.uuid().nullable(),
+});
+export type SkillPublicationReceipt = z.infer<typeof SkillPublicationReceipt>;
+export const SkillSourceReleaseReceipt = z.object({
+  skillId: z.uuid(),
+  revisionId: z.uuid().nullable(),
+  disposition: z.enum(["deactivated", "preserved", "inactive"]),
+  eventId: z.uuid().nullable(),
+  warning: z.string().nullable(),
+});
+export type SkillSourceReleaseReceipt = z.infer<typeof SkillSourceReleaseReceipt>;
+export type SkillRecord = {
+  removalOperationId?: string | null;
+  activationMode: "workspace_managed" | "session_selected";
+  pendingRevisionIds: string[];
+  id: string;
+  stableKey: string;
+  scope: SkillScope;
+  scopeVersion: number;
+  status: string;
+  activeRevisionId: string | null;
+  revisionId: string | null;
+  title: string | null;
+  description: string | null;
+  contentHash: string | null;
+  files: SkillFile[];
+  source: { pluginId: string; facetKey: string; skillFacetId: string } | null;
+};

package/src/slack-bot-scopes.ts

@@ -1,3 +1,5 @@
+import { OPENGENI_SLACK_REST_USER_SCOPES } from "./slack-rest-mcp";
+
 export const OPENGENI_SLACK_BOT_REQUIRED_SCOPES = [
   "app_mentions:read",
   "canvases:read",
@@ -19,20 +21,45 @@ export const OPENGENI_SLACK_BOT_REQUIRED_SCOPES = [
 /** Read-only scope needed only for the optional emoji-reaction summon surface. */
 export const OPENGENI_SLACK_REACTION_REQUIRED_SCOPE = "reactions:read" as const;
 
+/** Optional grant for explicit retained-file delivery to a task's Slack thread. */
+export const OPENGENI_SLACK_FILE_UPLOAD_REQUIRED_SCOPE = "files:write" as const;
+
+/**
+ * Bot-token search scopes for Slack's Real-time Search API
+ * (`assistant.search.context`). Slack accepts these as BOT scopes, so
+ * workspace-wide public search runs under the bot identity and never needs a
+ * human proxy token. Private-channel, DM, and MPIM search remain user-token
+ * only and belong exclusively to the personal hosted-MCP grant.
+ */
+export const OPENGENI_SLACK_BOT_SEARCH_SCOPES = [
+  "search:read.public",
+  "search:read.files",
+  "search:read.users",
+] as const;
+
 /**
  * Scopes requested by the managed and generated self-hosted manifests.
  *
- * `reactions:read` is deliberately not part of the base eligibility contract:
- * legacy installations may continue using existing Slack interactions and
- * tools while the reaction setting stays disabled and the UI asks an admin to
- * reinstall.
+ * `reactions:read`, `files:write`, and the bot search scopes are not part of the
+ * base eligibility contract: legacy installations may continue using existing
+ * Slack interactions and tools while the reaction setting stays disabled, bot
+ * search and file delivery stay unavailable, and the tools ask an admin to reinstall.
  */
 export const OPENGENI_SLACK_BOT_REQUESTED_SCOPES = [
   ...OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
   OPENGENI_SLACK_REACTION_REQUIRED_SCOPE,
+  OPENGENI_SLACK_FILE_UPLOAD_REQUIRED_SCOPE,
 ] as const;
 
+export function openGeniSlackBotRequestedScopes(mode: "limited" | "full" = "limited"): string[] {
+  return [
+    ...OPENGENI_SLACK_BOT_REQUESTED_SCOPES,
+    ...(mode === "full" ? OPENGENI_SLACK_BOT_SEARCH_SCOPES : []),
+  ];
+}
+
 export const OPENGENI_SLACK_BOT_EVENTS = [
+  "app_home_opened",
   "app_mention",
   "message.channels",
   "message.groups",
@@ -41,37 +68,42 @@ export const OPENGENI_SLACK_BOT_EVENTS = [
   "reaction_added",
 ] as const;
 
-/** Full user-token scope set for every tool currently exposed by Slack's hosted MCP server. */
-export const OPENGENI_SLACK_MCP_USER_SCOPES = [
-  "search:read.public",
-  "search:read.private",
-  "search:read.mpim",
-  "search:read.im",
-  "search:read.files",
-  "files:read",
-  "emoji:read",
-  "search:read.users",
-  "chat:write",
-  "channels:history",
-  "groups:history",
-  "mpim:history",
-  "im:history",
-  "channels:write",
-  "groups:write",
-  "im:write",
-  "mpim:write",
-  "reactions:write",
-  "canvases:read",
-  "canvases:write",
-  "users:read",
-  "users:read.email",
-  "channels:read",
-  "groups:read",
-  "mpim:read",
-] as const;
+/** User grants required by the reviewed Slack API MCP tools. */
+export const OPENGENI_SLACK_MCP_USER_SCOPES = OPENGENI_SLACK_REST_USER_SCOPES;
 
 export const OPENGENI_MANAGED_PUBLIC_BASE_URL = "https://app.opengeni.ai" as const;
 
+export type OpenGeniSlackBotManifestOptions = Readonly<{
+  appName?: string;
+  botDisplayName?: string;
+  slashCommand?: string;
+  shortcutName?: string;
+  accessMode?: "limited" | "full";
+}>;
+
+function normalizedSlackManifestText(
+  value: string | undefined,
+  fallback: string,
+  label: string,
+  maxLength: number,
+): string {
+  const normalized = value?.trim() || fallback;
+  if (normalized.length > maxLength || /[\r\n\0]/u.test(normalized)) {
+    throw new Error(`Slack bot manifest ${label} must be at most ${maxLength} plain characters`);
+  }
+  return normalized;
+}
+
+function normalizedSlackCommand(value: string | undefined): string {
+  const command = value?.trim() || "/opengeni";
+  if (!/^\/[a-z0-9_-]{1,31}$/u.test(command)) {
+    throw new Error(
+      "Slack bot manifest slash command must start with / and contain at most 31 lowercase letters, digits, hyphens, or underscores",
+    );
+  }
+  return command;
+}
+
 function normalizedSlackManifestBaseUrl(publicBaseUrl: string): string {
   const parsed = new URL(publicBaseUrl);
   if (parsed.protocol !== "https:" || parsed.username || parsed.password) {
@@ -84,16 +116,38 @@ function normalizedSlackManifestBaseUrl(publicBaseUrl: string): string {
 }
 
 /** Canonical managed/self-hosted Slack app manifest. Slack accepts JSON manifests. */
-export function buildOpenGeniSlackBotManifest(publicBaseUrl: string) {
+export function buildOpenGeniSlackBotManifest(
+  publicBaseUrl: string,
+  options: OpenGeniSlackBotManifestOptions = {},
+) {
   const baseUrl = normalizedSlackManifestBaseUrl(publicBaseUrl);
+  const appName = normalizedSlackManifestText(options.appName, "OpenGeni", "app name", 35);
+  const botDisplayName = normalizedSlackManifestText(
+    options.botDisplayName,
+    "OpenGeni",
+    "bot display name",
+    80,
+  );
+  const slashCommand = normalizedSlackCommand(options.slashCommand);
+  const shortcutName = normalizedSlackManifestText(
+    options.shortcutName,
+    "Open in Opengeni",
+    "shortcut name",
+    35,
+  );
   return {
-    display_information: { name: "OpenGeni" },
+    display_information: { name: appName },
     features: {
-      bot_user: { display_name: "OpenGeni", always_online: false },
+      app_home: {
+        home_tab_enabled: true,
+        messages_tab_enabled: true,
+        messages_tab_read_only_enabled: false,
+      },
+      bot_user: { display_name: botDisplayName, always_online: false },
       slash_commands: [
         {
-          command: "/opengeni",
-          description: "Start an OpenGeni task in this channel",
+          command: slashCommand,
+          description: "Start an Opengeni task in this channel",
           should_escape: false,
           url: `${baseUrl}/v1/integrations/slack/commands`,
         },
@@ -101,8 +155,8 @@ export function buildOpenGeniSlackBotManifest(publicBaseUrl: string) {
       shortcuts: [
         {
           callback_id: "opengeni_message",
-          description: "Start an OpenGeni task from this Slack message",
-          name: "Open in OpenGeni",
+          description: "Start an Opengeni task from this Slack message",
+          name: shortcutName,
           type: "message",
         },
       ],
@@ -113,7 +167,7 @@ export function buildOpenGeniSlackBotManifest(publicBaseUrl: string) {
         `${baseUrl}/v1/integrations/slack/callback`,
       ],
       scopes: {
-        bot: [...OPENGENI_SLACK_BOT_REQUESTED_SCOPES],
+        bot: openGeniSlackBotRequestedScopes(options.accessMode),
         user: [...OPENGENI_SLACK_MCP_USER_SCOPES],
       },
     },
@@ -135,15 +189,25 @@ export function buildOpenGeniSlackBotManifest(publicBaseUrl: string) {
 }
 
 /**
- * Optional bot grants that remain inside the shipped bot's read/identity
- * boundary. Every other unrequired scope fails closed, including unknown future
+ * Optional bot grants used by the shipped read/identity and task-file-delivery
+ * surfaces. Every other unrequired scope fails closed, including unknown future
  * Slack scopes, so verification, core routing, and UI eligibility cannot drift.
  */
 export const OPENGENI_SLACK_BOT_SAFE_OPTIONAL_SCOPES = [
   "team:read",
   OPENGENI_SLACK_REACTION_REQUIRED_SCOPE,
+  OPENGENI_SLACK_FILE_UPLOAD_REQUIRED_SCOPE,
+  ...OPENGENI_SLACK_BOT_SEARCH_SCOPES,
 ] as const;
 
+export function hasOpenGeniSlackFileUploadScope(grantedScopes: readonly string[]): boolean {
+  return grantedScopes.includes(OPENGENI_SLACK_FILE_UPLOAD_REQUIRED_SCOPE);
+}
+
+export function hasOpenGeniSlackBotSearchScopes(grantedScopes: readonly string[]): boolean {
+  return OPENGENI_SLACK_BOT_SEARCH_SCOPES.every((scope) => grantedScopes.includes(scope));
+}
+
 /** @deprecated Use evaluateOpenGeniSlackBotScopes; an allowlist is the policy. */
 export const OPENGENI_SLACK_BOT_FORBIDDEN_SCOPES = ["channels:join", "chat:write.public"] as const;