vellum 0.2.14 → 0.3.2

package/src/daemon/session-skill-tools.ts

@@ -1,356 +0,0 @@
-/**
- * Session-time projection of active skill tools.
- *
- * On each agent turn the conversation history (and any pre-activated IDs from
- * config or slash commands) determine which skills are "active".  This module
- * computes the union, loads tool manifests, registers new skill tools, tears
- * down tools for skills that are no longer active, and returns the projected
- * tool definitions so the agent loop can include them in the next request.
- */
-
-import type { Message, ToolDefinition } from '../providers/types.js';
-import type { SkillSummary, SkillToolManifest } from '../config/skills.js';
-import type { ActiveSkillEntry } from '../skills/active-skill-tools.js';
-import { loadSkillCatalog } from '../config/skills.js';
-import { deriveActiveSkills } from '../skills/active-skill-tools.js';
-
-import { parseToolManifestFile } from '../skills/tool-manifest.js';
-import { computeSkillVersionHash } from '../skills/version-hash.js';
-import { createSkillToolsFromManifest } from '../tools/skills/skill-tool-factory.js';
-import {
-  getTool,
-  registerSkillTools,
-  unregisterSkillTools,
-} from '../tools/registry.js';
-import { getLogger } from '../util/logger.js';
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
-
-const log = getLogger('session-skill-tools');
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-export interface SkillToolProjection {
-  /** Tool definitions to append to the agent's tool list for this turn. */
-  toolDefinitions: ToolDefinition[];
-  /** Tool names that belong to currently active skills. */
-  allowedToolNames: Set<string>;
-}
-
-/**
- * Session-scoped cache for skill projection. Avoids re-scanning the entire
- * conversation history and re-reading the filesystem on every agent turn.
- *
- * Each session should own its own cache instance to prevent cross-session
- * state bleed.
- */
-export interface SkillProjectionCache {
-  /** Cached deriveActiveSkills result. */
-  derived?: {
-    /** Number of messages in history when this cache was last computed. */
-    messageCount: number;
-    /** Reference to the first message when cache was computed. Compaction
-     *  replaces the first message with a new summary object, so a reference
-     *  mismatch signals that history was rewritten even if the count matches. */
-    firstMessage: Message | undefined;
-    /** IDs already seen — used for deduplication during incremental scans. */
-    seenIds: Set<string>;
-    /** The accumulated active skill entries. */
-    entries: ActiveSkillEntry[];
-  };
-  /** Cached skill catalog. Invalidated when the session is marked stale
-   *  (e.g. skill directories changed on disk while a run is in progress). */
-  catalog?: SkillSummary[];
-}
-
-export interface ProjectSkillToolsOptions {
-  /** Skill IDs that should be treated as active regardless of history markers. */
-  preactivatedSkillIds?: string[];
-  /**
-   * Session-scoped tracking map of previously active skill IDs to their
-   * version hashes. Each session should own its own map to prevent
-   * cross-session state bleed when the daemon serves multiple concurrent
-   * sessions. When a skill's hash changes between turns, its tools are
-   * unregistered and re-registered with the updated definitions.
-   */
-  previouslyActiveSkillIds?: Map<string, string>;
-  /**
-   * Session-scoped projection cache. When provided, projectSkillTools will
-   * avoid redundant deriveActiveSkills scans and loadSkillCatalog filesystem
-   * reads across agent turns.
-   */
-  cache?: SkillProjectionCache;
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Load and parse a skill's TOOLS.json manifest, returning null on any failure.
- */
-function loadManifestForSkill(skill: SkillSummary): SkillToolManifest | null {
-  const manifestPath = join(skill.directoryPath, 'TOOLS.json');
-  if (!existsSync(manifestPath)) {
-    log.debug({ skillId: skill.id, manifestPath }, 'No TOOLS.json found for skill');
-    return null;
-  }
-
-  try {
-    return parseToolManifestFile(manifestPath);
-  } catch (err) {
-    log.warn({ err, skillId: skill.id, manifestPath }, 'Failed to parse TOOLS.json for skill');
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Cache helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Return active skill entries, using the projection cache when available.
- *
- * History is append-only within a session (messages are only added, never
- * mutated in place). If history.length hasn't changed since the last scan,
- * the cached result is returned immediately. If new messages were appended,
- * only the delta is scanned and merged. If history shrank (e.g. compression
- * replaced earlier messages), the cache is invalidated and a full rescan
- * is performed.
- */
-function getCachedActiveSkills(
-  history: Message[],
-  cache?: SkillProjectionCache,
-): ActiveSkillEntry[] {
-  if (!cache) return deriveActiveSkills(history);
-
-  const cached = cache.derived;
-
-  // Fast path: history unchanged since last scan. Both the count and the
-  // first message reference must match — compaction can rewrite history
-  // without changing the total count.
-  if (cached && cached.messageCount === history.length && cached.firstMessage === history[0]) {
-    return cached.entries;
-  }
-
-  // History grew (and first message is unchanged) — scan only the new messages.
-  if (cached && cached.messageCount < history.length && cached.firstMessage === history[0]) {
-    const delta = history.slice(cached.messageCount);
-    const newEntries = deriveActiveSkills(delta);
-
-    // Merge: add any entries not already seen.
-    let changed = false;
-    for (const entry of newEntries) {
-      if (!cached.seenIds.has(entry.id)) {
-        cached.seenIds.add(entry.id);
-        cached.entries.push(entry);
-        changed = true;
-      }
-    }
-
-    cached.messageCount = history.length;
-    if (changed) {
-      log.debug(
-        { newEntries: newEntries.length, total: cached.entries.length },
-        'Incremental skill derivation found new entries',
-      );
-    }
-    return cached.entries;
-  }
-
-  // History shrank, compaction rewrote it, or no cache yet — full rescan.
-  const entries = deriveActiveSkills(history);
-  const seenIds = new Set(entries.map((e) => e.id));
-  cache.derived = { messageCount: history.length, firstMessage: history[0], seenIds, entries };
-  return entries;
-}
-
-/**
- * Return the skill catalog, caching it across agent turns.
- *
- * The cache is invalidated when the session is marked stale (e.g. skill
- * directories changed on disk while the session is still processing).
- */
-function getCachedCatalog(cache?: SkillProjectionCache): SkillSummary[] {
-  if (!cache) return loadSkillCatalog();
-
-  if (!cache.catalog) {
-    cache.catalog = loadSkillCatalog();
-  }
-  return cache.catalog;
-}
-
-// ---------------------------------------------------------------------------
-// Main export
-// ---------------------------------------------------------------------------
-
-/**
- * Compute the set of active skill tools for the current session turn.
- *
- * 1. Derives active skill IDs from conversation history markers.
- * 2. Merges with any preactivated IDs (union).
- * 3. For each newly-active skill, loads its TOOLS.json and registers tools.
- * 4. For each previously-active skill that is no longer active, unregisters.
- * 5. Returns projected tool definitions and the set of allowed tool names.
- */
-export function projectSkillTools(
-  history: Message[],
-  options?: ProjectSkillToolsOptions,
-): SkillToolProjection {
-  const contextEntries = getCachedActiveSkills(history, options?.cache);
-  const preactivated = options?.preactivatedSkillIds ?? [];
-  const prevActive = options?.previouslyActiveSkillIds ?? new Map<string, string>();
-
-  // Index marker versions by skill ID so we can use them during registration.
-  // When a marker carries a version, it records the hash that was active at
-  // load time — useful for detecting drift without re-hashing the directory.
-  const markerVersionById = new Map<string, string>();
-  for (const entry of contextEntries) {
-    if (entry.version) {
-      markerVersionById.set(entry.id, entry.version);
-    }
-  }
-
-  // Union of context-derived and preactivated IDs
-  const contextIds = contextEntries.map((e) => e.id);
-  const activeIds = new Set<string>([...contextIds, ...preactivated]);
-
-  // Determine which skills were removed since last projection
-  const removedIds = new Set<string>();
-  for (const id of prevActive.keys()) {
-    if (!activeIds.has(id)) {
-      removedIds.add(id);
-    }
-  }
-
-  // Unregister tools for skills that are no longer active
-  for (const id of removedIds) {
-    log.info({ skillId: id }, 'Unregistering tools for deactivated skill');
-    unregisterSkillTools(id);
-  }
-
-  // Early exit if nothing is active
-  if (activeIds.size === 0) {
-    prevActive.clear();
-    return { toolDefinitions: [], allowedToolNames: new Set() };
-  }
-
-  // Load the catalog (cached for session lifetime) and index by ID
-  const catalog = getCachedCatalog(options?.cache);
-  const catalogById = new Map<string, SkillSummary>();
-  for (const skill of catalog) {
-    catalogById.set(skill.id, skill);
-  }
-
-  const allToolDefinitions: ToolDefinition[] = [];
-  const allToolNames = new Set<string>();
-  const successfulEntries = new Map<string, string>();
-  // Track skills already unregistered in the version-change branch so the
-  // transiently-failed cleanup loop doesn't double-decrement their refcount.
-  const alreadyUnregistered = new Set<string>();
-
-  for (const skillId of activeIds) {
-    const skill = catalogById.get(skillId);
-    if (!skill) {
-      log.warn({ skillId }, 'Active skill ID not found in catalog');
-      continue;
-    }
-
-    const manifest = loadManifestForSkill(skill);
-    if (!manifest) {
-      continue;
-    }
-
-    // Compute the current version hash for this skill directory
-    let currentHash: string;
-    try {
-      currentHash = computeSkillVersionHash(skill.directoryPath);
-    } catch (err) {
-      log.warn({ err, skillId }, 'Failed to compute skill version hash, treating as changed');
-      currentHash = `unknown-${Date.now()}`;
-    }
-
-    // Create runtime Tool objects
-    const tools = createSkillToolsFromManifest(
-      manifest.tools,
-      skillId,
-      skill.directoryPath,
-      currentHash,
-      skill.bundled,
-    );
-
-    if (tools.length > 0) {
-      const prevHash = prevActive.get(skillId);
-      if (prevHash === undefined) {
-        // Newly active skill — register for the first time
-        registerSkillTools(tools);
-      } else if (prevHash !== currentHash) {
-        // Hash changed — unregister stale tools, then re-register with new definitions
-        log.info({ skillId, prevHash, currentHash }, 'Skill version changed, re-registering tools');
-        unregisterSkillTools(skillId);
-        alreadyUnregistered.add(skillId);
-        try {
-          registerSkillTools(tools);
-        } catch (err) {
-          log.error({ err, skillId }, 'Failed to re-register skill tools after version change');
-          // Don't add to successfulEntries — will be cleaned up as transiently-failed
-          continue;
-        }
-      } else {
-        // Hash unchanged — check if the bundled status drifted (e.g. a
-        // managed skill override was added/removed with identical content).
-        // Re-register so the ownerSkillBundled flag stays accurate.
-        const existing = getTool(tools[0].name);
-        if (existing && existing.ownerSkillBundled !== (skill.bundled ?? undefined)) {
-          log.info({ skillId, bundled: skill.bundled }, 'Skill bundled status changed, re-registering tools');
-          unregisterSkillTools(skillId);
-          registerSkillTools(tools);
-        }
-      }
-
-      successfulEntries.set(skillId, currentHash);
-      for (const tool of tools) {
-        allToolDefinitions.push(tool.getDefinition());
-        allToolNames.add(tool.name);
-      }
-    }
-  }
-
-  // Unregister skills that were previously active but failed processing this
-  // turn (catalog miss, manifest failure, empty tools). Without this, the
-  // skill would be re-registered when it recovers next turn, inflating the
-  // refcount since the prior registration was never decremented.
-  for (const id of prevActive.keys()) {
-    if (activeIds.has(id) && !successfulEntries.has(id) && !alreadyUnregistered.has(id)) {
-      log.info({ skillId: id }, 'Unregistering tools for transiently-failed skill');
-      unregisterSkillTools(id);
-    }
-  }
-
-  // Update the session-scoped tracking map in-place — only include skills
-  // that were successfully processed so failed skills can be retried next turn.
-  prevActive.clear();
-  for (const [id, hash] of successfulEntries) {
-    prevActive.set(id, hash);
-  }
-
-  return {
-    toolDefinitions: allToolDefinitions,
-    allowedToolNames: allToolNames,
-  };
-}
-
-/**
- * Reset the projection state and unregister all skill tools tracked in the
- * given map. Used for session teardown and tests.
- */
-export function resetSkillToolProjection(trackedIds?: Map<string, string>): void {
-  if (trackedIds) {
-    for (const id of trackedIds.keys()) {
-      unregisterSkillTools(id);
-    }
-    trackedIds.clear();
-  }
-}

package/src/daemon/session-slash.ts

@@ -1,305 +0,0 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { getConfig, loadRawConfig, saveRawConfig } from '../config/loader.js';
-import { initializeProviders } from '../providers/registry.js';
-import { loadSkillCatalog } from '../config/skills.js';
-import { resolveSkillStates } from '../config/skill-state.js';
-import {
-  buildInvocableSlashCatalog,
-  resolveSlashSkillCommand,
-  rewriteKnownSlashCommandPrompt,
-} from '../skills/slash-commands.js';
-import { getWorkspacePromptPath } from '../util/platform.js';
-
-export type SlashResolution =
-  | { kind: 'passthrough'; content: string }
-  | { kind: 'rewritten'; content: string; skillId: string }
-  | { kind: 'unknown'; message: string };
-
-// ── /model command ───────────────────────────────────────────────────
-
-const AVAILABLE_MODELS = [
-  'claude-opus-4-6',
-  'claude-opus-4-6-fast',
-  'claude-sonnet-4-6',
-  'claude-haiku-4-5-20251001',
-] as const;
-
-const MODEL_DISPLAY_NAMES: Record<string, string> = {
-  'claude-opus-4-6': 'Claude Opus 4.6',
-  'claude-opus-4-6-fast': 'Claude Opus 4.6 Fast',
-  'claude-sonnet-4-6': 'Claude Sonnet 4.6',
-  'claude-haiku-4-5-20251001': 'Claude Haiku 4.5',
-};
-
-const PROVIDER_MODEL_SHORTCUTS: Record<string, { provider: string; model: string; displayName: string }> = {
-  // Anthropic
-  'opus': { provider: 'anthropic', model: 'claude-opus-4-6', displayName: 'Claude Opus 4.6' },
-  'opus-fast': { provider: 'anthropic', model: 'claude-opus-4-6-fast', displayName: 'Claude Opus 4.6 Fast' },
-  'sonnet': { provider: 'anthropic', model: 'claude-sonnet-4-6', displayName: 'Claude Sonnet 4.6' },
-  'haiku': { provider: 'anthropic', model: 'claude-haiku-4-5-20251001', displayName: 'Claude Haiku 4.5' },
-
-  // OpenAI
-  'gpt4': { provider: 'openai', model: 'gpt-4', displayName: 'GPT-4' },
-  'gpt4o': { provider: 'openai', model: 'gpt-4o', displayName: 'GPT-4o' },
-  'gpt5': { provider: 'openai', model: 'gpt-5.2', displayName: 'GPT-5.2' },
-
-  // Gemini
-  'gemini': { provider: 'gemini', model: 'gemini-3-flash', displayName: 'Gemini 3 Flash' },
-
-  // Ollama
-  'ollama': { provider: 'ollama', model: 'llama3.2', displayName: 'Llama 3.2' },
-
-  // Fireworks
-  'fireworks': { provider: 'fireworks', model: 'accounts/fireworks/models/kimi-k2p5', displayName: 'Kimi K2.5' },
-
-  // OpenRouter
-  'openrouter': { provider: 'openrouter', model: 'x-ai/grok-4', displayName: 'Grok 4 (OpenRouter)' },
-};
-
-/** Reverse lookup: model ID → provider, derived from PROVIDER_MODEL_SHORTCUTS. */
-export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
-  Object.values(PROVIDER_MODEL_SHORTCUTS).map(({ model, provider }) => [model, provider]),
-);
-
-/** Read the assistant's name from IDENTITY.md for personalized responses. */
-function getAssistantName(): string | null {
-  try {
-    const path = getWorkspacePromptPath('IDENTITY.md');
-    if (!existsSync(path)) return null;
-    const content = readFileSync(path, 'utf-8');
-    const match = content.match(/\*\*Name:\*\*\s*(.+)/);
-    return match?.[1]?.trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-/** Partial-match a user input like "opus", "sonnet", "haiku" to a full model ID. */
-function matchModel(input: string): string | undefined {
-  const lower = input.toLowerCase().trim();
-  // Exact match first
-  const exact = AVAILABLE_MODELS.find((m) => m === lower);
-  if (exact) return exact;
-  // Partial match (e.g. "opus" → "claude-opus-4-6")
-  return AVAILABLE_MODELS.find((m) => m.includes(lower));
-}
-
-function resolveProviderModelCommand(content: string): SlashResolution | null {
-  const trimmed = content.trim();
-  if (!trimmed.startsWith('/')) return null;
-
-  // Extract the command (e.g., "/gpt4" → "gpt4")
-  const match = trimmed.match(/^\/([a-z0-9-]+)(\s|$)/i);
-  if (!match) return null;
-
-  const command = match[1].toLowerCase();
-  const shortcut = PROVIDER_MODEL_SHORTCUTS[command];
-  if (!shortcut) return null;
-
-  const { provider, model, displayName } = shortcut;
-  const config = getConfig();
-  const name = getAssistantName();
-
-  // Check if API key exists for this provider (Ollama doesn't require an API key)
-  if (provider !== 'ollama' && !config.apiKeys[provider]) {
-    return {
-      kind: 'unknown',
-      message: `Cannot switch to ${displayName}. No API key configured for ${provider}.\n\nSet it with: \`config set apiKeys.${provider} <your-key>\``,
-    };
-  }
-
-  // Check if already using this provider+model
-  if (config.provider === provider && config.model === model) {
-    const alreadyMsg = name
-      ? `${name} is already running on **${displayName}**.`
-      : `Already using **${displayName}**.`;
-    return {
-      kind: 'unknown',
-      message: alreadyMsg,
-    };
-  }
-
-  // Update config with both provider and model
-  const raw = loadRawConfig();
-  raw.provider = provider;
-  raw.model = model;
-  saveRawConfig(raw);
-
-  // Re-initialize providers with new config
-  const newConfig = getConfig();
-  initializeProviders(newConfig);
-
-  const switchedMsg = name
-    ? `Switched ${name} to **${displayName}**. New conversations will use this model.`
-    : `Switched to **${displayName}**. New conversations will use this model.`;
-
-  return {
-    kind: 'unknown',
-    message: switchedMsg,
-  };
-}
-
-function resolveModelList(): SlashResolution {
-  const config = getConfig();
-  const lines = ['Available models:\n'];
-
-  for (const [cmd, { provider, model, displayName }] of Object.entries(PROVIDER_MODEL_SHORTCUTS)) {
-    const hasKey = provider === 'ollama' || !!config.apiKeys[provider];
-    const isCurrent = config.provider === provider && config.model === model;
-    const status = hasKey ? '✓' : '✗';
-    const current = isCurrent ? ' **[current]**' : '';
-    lines.push(`- **${displayName}** (/${cmd}) ${status}${current}`);
-  }
-
-  lines.push('\n✓ = API key configured, ✗ = not configured');
-  lines.push('\nTip: Configure a provider with `config set apiKeys.<provider> <key>`');
-
-  return {
-    kind: 'unknown',
-    message: lines.join('\n'),
-  };
-}
-
-function resolveModelCommand(content: string): SlashResolution | null {
-  const trimmed = content.trim();
-  // Match /models → route to list
-  if (trimmed === '/models') {
-    return resolveModelList();
-  }
-
-  if (!trimmed.startsWith('/model')) return null;
-  // Ensure it's exactly "/model" or "/model " (not "/modelsomething")
-  if (trimmed.length > 6 && trimmed[6] !== ' ') return null;
-
-  const args = trimmed.slice(6).trim();
-  const name = getAssistantName();
-
-  if (!args) {
-    // Show current model
-    const config = getConfig();
-    const displayName = MODEL_DISPLAY_NAMES[config.model] ?? config.model;
-    const prefix = name ? `${name} is running on` : `Currently using`;
-    return {
-      kind: 'unknown',
-      message: `${prefix} **${displayName}** (\`${config.model}\`).`,
-    };
-  }
-
-  // Handle /model list
-  if (args === 'list') {
-    return resolveModelList();
-  }
-
-  // Try to match the model name
-  const matched = matchModel(args);
-  if (!matched) {
-    const available = AVAILABLE_MODELS.map(
-      (m) => `- **${MODEL_DISPLAY_NAMES[m]}** (\`${m}\`)`,
-    ).join('\n');
-    return {
-      kind: 'unknown',
-      message: `Hmm, "${args}" doesn't match any available model. Here's what you can pick from:\n${available}`,
-    };
-  }
-
-  // Check if already using this model
-  const currentConfig = getConfig();
-  if (currentConfig.model === matched) {
-    const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
-    const alreadyMsg = name
-      ? `${name} is already running on **${displayName}**.`
-      : `Already on **${displayName}**.`;
-    return {
-      kind: 'unknown',
-      message: alreadyMsg,
-    };
-  }
-
-  // Validate that Anthropic provider is available
-  if (!currentConfig.apiKeys.anthropic) {
-    const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
-    return {
-      kind: 'unknown',
-      message: `Cannot switch to ${displayName}. No API key configured for Anthropic.\n\nSet it with: \`config set apiKeys.anthropic <your-key>\``,
-    };
-  }
-
-  // Change model: save config and re-initialize providers
-  const raw = loadRawConfig();
-  raw.provider = 'anthropic'; // Ensure provider is set for Anthropic models
-  raw.model = matched;
-  saveRawConfig(raw);
-  const config = getConfig();
-  initializeProviders(config);
-
-  const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
-  const switchedMsg = name
-    ? `Switched ${name} to **${displayName}**. New conversations will use this model.`
-    : `Switched to **${displayName}**. New conversations will use this model.`;
-  return {
-    kind: 'unknown',
-    message: switchedMsg,
-  };
-}
-
-/**
- * Resolve slash commands against the current skill catalog.
- * Returns `unknown` with a deterministic message, or the (possibly rewritten) content.
- */
-export function resolveSlash(content: string): SlashResolution {
-  // Check provider shortcuts first (/gpt4, /opus, etc.)
-  const providerResult = resolveProviderModelCommand(content);
-  if (providerResult) return providerResult;
-
-  // Handle /model command
-  const modelResult = resolveModelCommand(content);
-  if (modelResult) return modelResult;
-
-  // Handle /commands command
-  if (content.trim() === '/commands') {
-    return {
-      kind: 'unknown',
-      message: '/commands — List all available commands\n/model — Show or switch the current model\n/models — List all available models',
-    };
-  }
-
-  const config = getConfig();
-  const catalog = loadSkillCatalog();
-  const resolved = resolveSkillStates(catalog, config);
-  const invocable = buildInvocableSlashCatalog(catalog, resolved);
-  const resolution = resolveSlashSkillCommand(content, invocable);
-
-  if (resolution.kind === 'known') {
-    const skill = invocable.get(resolution.skillId.toLowerCase());
-    return {
-      kind: 'rewritten',
-      content: rewriteKnownSlashCommandPrompt({
-        rawInput: content,
-        skillId: resolution.skillId,
-        skillName: skill?.name ?? resolution.skillId,
-        trailingArgs: resolution.trailingArgs,
-      }),
-      skillId: resolution.skillId,
-    };
-  }
-
-  if (resolution.kind === 'unknown') {
-    return { kind: 'unknown', message: resolution.message };
-  }
-
-  return { kind: 'passthrough', content };
-}
-
-// ── Provider Ordering Error Detection ────────────────────────────────
-
-const ORDERING_ERROR_PATTERNS = [
-  /tool_result.*not immediately after.*tool_use/i,
-  /tool_use.*must have.*tool_result/i,
-  /tool_use_id.*without.*tool_result/i,
-  /tool_result.*tool_use_id.*not found/i,
-  /messages.*invalid.*order/i,
-];
-
-export function isProviderOrderingError(message: string): boolean {
-  return ORDERING_ERROR_PATTERNS.some((pattern) => pattern.test(message));
-}