thumbgate 1.27.16 → 1.27.18

package/scripts/llm-client.js

@@ -4,94 +4,27 @@
 const { runStep } = require('./durability/step');
 
 const MODELS = {
-  FAST: 'glm-5.2',
-  SMART: 'glm-5.2',
-  ZAI_CODING: 'glm-5.2',
-  LEGACY_CLAUDE_FAST: 'claude-haiku-4-5-20251001',
-  LEGACY_CLAUDE_SMART: 'claude-sonnet-4-6',
+  FAST: 'claude-haiku-4-5-20251001',
+  SMART: 'claude-sonnet-4-6',
 };
 
 const DEFAULT_MODEL = MODELS.FAST;
 const DEFAULT_MAX_TOKENS = 1024;
 const DEFAULT_CACHE_TTL = '5m';
-const DEFAULT_ZAI_BASE_URL = 'https://api.z.ai/api/coding/paas/v4';
-const DEFAULT_ZAI_MODEL = MODELS.ZAI_CODING;
-const DEFAULT_OMLX_BASE_URL = 'http://127.0.0.1:8000/v1';
-const DEFAULT_OMLX_MODEL = 'qwen3-coder-next';
 
-let _anthropicClient = null;
-let _geminiClient = null;
+let _client = null;
 
-function getZaiApiKey(env = process.env) {
-  return env.ZAI_API_KEY || env.THUMBGATE_ZAI_API_KEY || env.GLM_API_KEY || '';
-}
-
-function getZaiBaseUrl(env = process.env) {
-  return (env.ZAI_API_BASE_URL || env.THUMBGATE_ZAI_API_BASE_URL || DEFAULT_ZAI_BASE_URL).replace(/\/+$/, '');
-}
-
-function getZaiModel(env = process.env) {
-  return env.ZAI_API_MODEL || env.THUMBGATE_ZAI_MODEL || DEFAULT_ZAI_MODEL;
-}
-
-function getOmlxApiKey(env = process.env) {
-  return env.OMLX_API_KEY || env.THUMBGATE_OMLX_API_KEY || '';
-}
-
-function getOmlxBaseUrl(env = process.env) {
-  return (env.OMLX_BASE_URL || env.THUMBGATE_OMLX_BASE_URL || DEFAULT_OMLX_BASE_URL)
-    .replace(/\/chat\/completions\/?$/i, '')
-    .replace(/\/+$/, '');
-}
-
-function getOmlxModel(env = process.env) {
-  return env.OMLX_MODEL || env.THUMBGATE_OMLX_MODEL || DEFAULT_OMLX_MODEL;
-}
-
-function hasZaiApiKey(env = process.env) {
-  return Boolean(getZaiApiKey(env));
-}
-
-function hasOmlxConfig(env = process.env) {
-  return env.THUMBGATE_LLM_PROVIDER === 'omlx'
-    || env.LLM_PROVIDER === 'omlx'
-    || env.THUMBGATE_OMLX_ENABLED === '1'
-    || env.OMLX_ENABLED === '1'
-    || Boolean(env.OMLX_BASE_URL || env.THUMBGATE_OMLX_BASE_URL);
-}
-
-function isZaiProvider(provider = '') {
-  return /^(zai|z\.ai|glm|glm-coding)$/i.test(String(provider || '').trim());
-}
-
-function isOmlxProvider(provider = '') {
-  return /^(omlx|local-omlx|mlx-local)$/i.test(String(provider || '').trim());
-}
-
-function isZaiModel(model = '') {
-  return /^(glm|zai|z\.ai)/i.test(String(model || '').trim());
-}
-
-function isAvailable(provider = '') {
-  const normalizedProvider = String(provider || '').trim().toLowerCase();
-  if (isZaiProvider(normalizedProvider)) return hasZaiApiKey();
-  if (isOmlxProvider(normalizedProvider)) return hasOmlxConfig();
-  if (normalizedProvider === 'anthropic' || normalizedProvider === 'claude') {
-    return Boolean(process.env.ANTHROPIC_API_KEY);
-  }
-  if (normalizedProvider === 'gemini' || normalizedProvider === 'vertex') {
-    return Boolean(process.env.GEMINI_API_KEY || process.env.VERTEX_PROJECT_ID);
-  }
-  return Boolean(hasOmlxConfig() || hasZaiApiKey() || process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY || process.env.VERTEX_PROJECT_ID);
+function isAvailable() {
+  return Boolean(process.env.ANTHROPIC_API_KEY);
 }
 
 function getClient() {
-  if (_anthropicClient) return _anthropicClient;
-  if (!isAvailable('anthropic')) return null;
+  if (_client) return _client;
+  if (!isAvailable()) return null;
   try {
     const Anthropic = require('@anthropic-ai/sdk');
-    _anthropicClient = new Anthropic();
-    return _anthropicClient;
+    _client = new Anthropic();
+    return _client;
   } catch {
     return null;
   }
@@ -189,63 +122,6 @@ function buildClaudeRequest({
   return request;
 }
 
-function normalizeMessageText(content) {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (typeof part === 'string') return part;
-      if (part && typeof part === 'object') return part.text || JSON.stringify(part);
-      return '';
-    }).join('');
-  }
-  if (content && typeof content === 'object') {
-    return content.text || JSON.stringify(content);
-  }
-  return '';
-}
-
-function convertMessagesToOpenAi(messages, userPrompt, systemPrompt) {
-  const normalized = [];
-  if (systemPrompt) normalized.push({ role: 'system', content: systemPrompt });
-
-  const list = Array.isArray(messages) && messages.length > 0
-    ? messages
-    : [{ role: 'user', content: userPrompt }];
-
-  for (const message of list) {
-    if (!message || typeof message !== 'object') continue;
-    const role = message.role === 'assistant' || message.role === 'system' ? message.role : 'user';
-    const content = normalizeMessageText(message.content);
-    if (content) normalized.push({ role, content });
-  }
-
-  if (normalized.length === 0) {
-    normalized.push({ role: 'user', content: String(userPrompt || '') });
-  }
-
-  return normalized;
-}
-
-function buildOpenAiCompatibleRequest({
-  systemPrompt,
-  userPrompt,
-  messages,
-  model,
-  maxTokens,
-  temperature,
-  metadata,
-} = {}, env = process.env) {
-  const request = {
-    model: model || getZaiModel(env),
-    messages: convertMessagesToOpenAi(messages, userPrompt, systemPrompt),
-    max_tokens: maxTokens || DEFAULT_MAX_TOKENS,
-  };
-
-  if (Number.isFinite(temperature)) request.temperature = temperature;
-  if (metadata && typeof metadata === 'object') request.metadata = metadata;
-  return request;
-}
-
 function extractTextContent(response) {
   return (response?.content || [])
     .filter((block) => block.type === 'text')
@@ -262,192 +138,7 @@ function parseClaudeJson(text) {
   }
 }
 
-async function callZaiInternal(options = {}) {
-  const apiKey = getZaiApiKey();
-  if (!apiKey) return null;
-  if (typeof fetch !== 'function') return null;
-
-  const baseUrl = getZaiBaseUrl();
-  const requestedModel = options.model && isZaiModel(options.model) ? options.model : undefined;
-  const request = buildOpenAiCompatibleRequest({
-    ...options,
-    model: requestedModel || getZaiModel(),
-  });
-
-  try {
-    const response = await runStep('llm.callZai', {
-      retries: 2,
-      logger: (msg) => console.warn(msg),
-    }, async () => fetch(`${baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(request),
-    }));
-
-    if (!response || !response.ok) {
-      throw new Error(`Z.ai request failed with status ${response?.status || 'unknown'}`);
-    }
-
-    const json = await response.json();
-    const text = stripCodeFences(json?.choices?.[0]?.message?.content || '');
-    return {
-      text,
-      usage: json?.usage || null,
-      stopReason: json?.choices?.[0]?.finish_reason || null,
-      id: json?.id || null,
-      model: json?.model || request.model,
-      provider: 'zai',
-    };
-  } catch (err) {
-    console.error('Z.ai execution error:', err?.message || err);
-    return null;
-  }
-}
-
-async function callOmlxInternal(options = {}) {
-  if (!hasOmlxConfig()) return null;
-  if (typeof fetch !== 'function') return null;
-
-  const baseUrl = getOmlxBaseUrl();
-  const request = buildOpenAiCompatibleRequest({
-    ...options,
-    model: options.model || getOmlxModel(),
-  });
-  const apiKey = getOmlxApiKey();
-  const headers = {
-    'Content-Type': 'application/json',
-  };
-  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-
-  try {
-    const response = await runStep('llm.callOmlx', {
-      retries: 1,
-      logger: (msg) => console.warn(msg),
-    }, async () => fetch(`${baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(request),
-    }));
-
-    if (!response || !response.ok) {
-      throw new Error(`oMLX request failed with status ${response?.status || 'unknown'}`);
-    }
-
-    const json = await response.json();
-    const text = stripCodeFences(json?.choices?.[0]?.message?.content || '');
-    return {
-      text,
-      usage: json?.usage || null,
-      stopReason: json?.choices?.[0]?.finish_reason || null,
-      id: json?.id || null,
-      model: json?.model || request.model,
-      provider: 'omlx',
-    };
-  } catch (err) {
-    console.error('oMLX execution error:', err?.message || err);
-    return null;
-  }
-}
-
-async function callGeminiInternal(options = {}) {
-  const env = process.env;
-  const { detectInferenceBackend } = require('./local-model-profile');
-  const providerMode = detectInferenceBackend(env).providerMode;
-
-  try {
-    const { GoogleGenAI } = require('@google/genai');
-    if (!_geminiClient) {
-      if (providerMode === 'vertex') {
-        _geminiClient = new GoogleGenAI({
-          enterprise: true,
-          project: env.VERTEX_PROJECT_ID || 'ai-revenue28-webhook',
-          location: env.VERTEX_LOCATION || 'us-central1',
-        });
-      } else {
-        _geminiClient = new GoogleGenAI({
-          apiKey: env.GEMINI_API_KEY,
-        });
-      }
-    }
-
-    const contents = convertMessagesToGemini(options.messages, options.userPrompt);
-    const config = {};
-    if (options.systemPrompt) {
-      config.systemInstruction = options.systemPrompt;
-    }
-    if (Number.isFinite(options.temperature)) {
-      config.temperature = options.temperature;
-    }
-    if (options.maxTokens) {
-      config.maxOutputTokens = options.maxTokens;
-    }
-
-    const response = await runStep('llm.callGemini', {
-      retries: 2,
-      logger: (msg) => console.warn(msg),
-    }, async () => _geminiClient.models.generateContent({
-      model: options.model,
-      contents,
-      config,
-    }));
-
-    return {
-      text: response.text || '',
-      usage: response.usageMetadata ? {
-        input_tokens: response.usageMetadata.promptTokenCount,
-        output_tokens: response.usageMetadata.candidatesTokenCount,
-      } : null,
-      stopReason: response.candidates?.[0]?.finishReason || null,
-      id: null,
-      model: options.model,
-    };
-  } catch (err) {
-    console.error('Gemini/Vertex AI execution error:', err);
-    return null;
-  }
-}
-
-function convertMessagesToGemini(messages, userPrompt) {
-  const list = Array.isArray(messages) && messages.length > 0
-    ? messages
-    : [{ role: 'user', content: userPrompt }];
-
-  return list.map((msg) => {
-    const role = msg.role === 'assistant' ? 'model' : 'user';
-    let text = '';
-    if (typeof msg.content === 'string') {
-      text = msg.content;
-    } else if (Array.isArray(msg.content)) {
-      text = msg.content.map((c) => c.text || '').join('');
-    } else if (msg.content && typeof msg.content === 'object') {
-      text = msg.content.text || JSON.stringify(msg.content);
-    }
-    return {
-      role,
-      parts: [{ text }],
-    };
-  });
-}
-
 async function callClaudeInternal(options = {}) {
-  const modelName = options.model || '';
-  const provider = options.provider || process.env.THUMBGATE_LLM_PROVIDER || process.env.LLM_PROVIDER || '';
-  const requestedZai = isZaiProvider(provider) || isZaiModel(modelName);
-  if (isOmlxProvider(provider)) {
-    return callOmlxInternal(options);
-  }
-  if (requestedZai || (!process.env.ANTHROPIC_API_KEY && hasZaiApiKey() && !modelName.startsWith('gemini') && !modelName.startsWith('vertex'))) {
-    const zaiOptions = requestedZai ? options : { ...options, model: undefined };
-    return callZaiInternal(zaiOptions);
-  }
-
-  if (modelName.startsWith('gemini') || modelName.startsWith('vertex')) {
-    return callGeminiInternal(options);
-  }
-
   const client = getClient();
   if (!client) return null;
 
@@ -496,63 +187,6 @@ async function callClaudeJson(options = {}) {
       stopReason: result.stopReason,
       id: result.id,
       model: result.model,
-      provider: result.provider || 'anthropic',
-    };
-  }
-
-  return parsed;
-}
-
-async function callZai(options = {}) {
-  const result = await callZaiInternal(options);
-  if (!result) return null;
-  return options.returnMetadata ? result : result.text;
-}
-
-async function callZaiJson(options = {}) {
-  const result = await callZaiInternal(options);
-  if (!result) return null;
-
-  const parsed = parseClaudeJson(result.text);
-  if (parsed === null) return null;
-
-  if (options.returnMetadata) {
-    return {
-      parsed,
-      text: result.text,
-      usage: result.usage,
-      stopReason: result.stopReason,
-      id: result.id,
-      model: result.model,
-      provider: result.provider,
-    };
-  }
-
-  return parsed;
-}
-
-async function callOmlx(options = {}) {
-  const result = await callOmlxInternal(options);
-  if (!result) return null;
-  return options.returnMetadata ? result : result.text;
-}
-
-async function callOmlxJson(options = {}) {
-  const result = await callOmlxInternal(options);
-  if (!result) return null;
-
-  const parsed = parseClaudeJson(result.text);
-  if (parsed === null) return null;
-
-  if (options.returnMetadata) {
-    return {
-      parsed,
-      text: result.text,
-      usage: result.usage,
-      stopReason: result.stopReason,
-      id: result.id,
-      model: result.model,
-      provider: result.provider,
     };
   }
 
@@ -563,24 +197,9 @@ module.exports = {
   isAvailable,
   callClaude,
   callClaudeJson,
-  callZai,
-  callZaiJson,
-  callOmlx,
-  callOmlxJson,
   stripCodeFences,
   parseClaudeJson,
   normalizeCacheOptions,
   buildClaudeRequest,
-  buildOpenAiCompatibleRequest,
-  convertMessagesToOpenAi,
-  getZaiApiKey,
-  getZaiBaseUrl,
-  getZaiModel,
-  getOmlxApiKey,
-  getOmlxBaseUrl,
-  getOmlxModel,
   MODELS,
-  DEFAULT_ZAI_BASE_URL,
-  DEFAULT_OMLX_BASE_URL,
-  DEFAULT_OMLX_MODEL,
 };

package/scripts/local-model-profile.js

@@ -111,8 +111,7 @@ function isSparseAttentionFamily(modelFamily) {
 
 function resolveProviderMode(env = process.env) {
   const explicit = normalizeSlug(env.THUMBGATE_PROVIDER_MODE || env.THUMBGATE_MODEL_PROVIDER_MODE);
-  if (explicit === 'local' || explicit === 'managed' || explicit === 'vertex') return explicit;
-  if (env.VERTEX_PROJECT_ID || env.VERTEX_API_ENDPOINT) return 'vertex';
+  if (explicit === 'local' || explicit === 'managed') return explicit;
   if (env.THUMBGATE_LOCAL_MODEL_FAMILY || env.THUMBGATE_LOCAL_MODEL_SERVER) return 'local';
   return 'managed';
 }
@@ -134,7 +133,6 @@ function resolveModelFamily(env = process.env) {
 }
 
 function buildBackendLabel(providerMode, modelFamily) {
-  if (providerMode === 'vertex') return 'Vertex AI secure cloud backend';
   if (providerMode === 'managed') return 'Managed API backend';
   if (modelFamily.startsWith('deepseek')) return 'Local DeepSeek sparse backend';
   if (modelFamily.startsWith('glm')) return 'Local GLM sparse backend';
@@ -150,18 +148,14 @@ function detectInferenceBackend(env = process.env) {
     && supportsSparseAttention
     && INDEXCACHE_SERVER_ENGINES.has(serverEngine);
   const indexCacheEnabled = indexCacheEligible && parseBoolean(env.THUMBGATE_INDEXCACHE_ENABLED, false);
-  const id = providerMode === 'vertex'
-    ? 'vertex-api'
-    : providerMode === 'managed'
-      ? 'managed-api'
-      : supportsSparseAttention
-        ? `local-${modelFamily}-sparse`
-        : 'local-dense';
+  const id = providerMode === 'managed'
+    ? 'managed-api'
+    : supportsSparseAttention
+      ? `local-${modelFamily}-sparse`
+      : 'local-dense';
 
   let rationale = 'Baseline backend with no sparse-attention acceleration.';
-  if (providerMode === 'vertex') {
-    rationale = 'Vertex AI secure cloud backend providing compliant enterprise Gemini models inside VPC boundary.';
-  } else if (providerMode === 'managed') {
+  if (providerMode === 'managed') {
     rationale = 'Managed API path does not expose sparse-attention kernel controls like IndexCache.';
   } else if (indexCacheEnabled) {
     rationale = `Local ${modelFamily} backend is sparse-attention capable and IndexCache-ready on ${serverEngine}.`;
@@ -342,8 +336,7 @@ function resolveModelRole(role, env) {
   const envKey = `THUMBGATE_MODEL_ROLE_${normalized.toUpperCase()}`;
   const modelFamily = resolveModelFamily(e);
   const isLocalGlm = modelFamily.startsWith('glm');
-  const providerMode = resolveProviderMode(e);
-  const provider = isLocalGlm ? 'local' : (providerMode === 'vertex' ? 'vertex' : 'gemini');
+  const provider = isLocalGlm ? 'local' : 'gemini';
   const defaultModel = isLocalGlm ? (GLM_MODEL_ROLES[normalized] || MODEL_ROLES[normalized]) : MODEL_ROLES[normalized];
   const model = (e[envKey] && String(e[envKey]).trim()) || defaultModel;
   return { role: normalized, model, provider, envKey };

package/scripts/memory-scope-readiness.js

@@ -2,38 +2,6 @@
 'use strict';
 
 const REQUIRED_SCOPE_FIELDS = ['entityId', 'projectId', 'processId', 'sessionId'];
-const MEMORY_OS_LAYERS = Object.freeze([
-  {
-    id: 'file_layer',
-    name: 'File Layer',
-    purpose: 'Raw feedback, tool receipts, sessions, and memory rows are durably stored before interpretation.',
-  },
-  {
-    id: 'vector_db_layer',
-    name: 'Vector DB Layer',
-    purpose: 'Semantic retrieval can find related lessons without stuffing every raw memory into context.',
-  },
-  {
-    id: 'structured_facts_layer',
-    name: 'Structured Facts Layer',
-    purpose: 'Confirmed account, project, policy, and budget facts are typed separately from fuzzy memories.',
-  },
-  {
-    id: 'auto_curation_layer',
-    name: 'Auto Curation Layer',
-    purpose: 'Duplicate, stale, contradictory, and unscoped memories are consolidated before retrieval quality decays.',
-  },
-  {
-    id: 'context_layer',
-    name: 'Context Layer',
-    purpose: 'Only relevant scoped memories enter a given tool call, PR, deployment, or support session.',
-  },
-  {
-    id: 'interface_layer',
-    name: 'Interface Layer',
-    purpose: 'The memory contract is exposed through CLI, MCP, hooks, dashboards, and agent adapters without model lock-in.',
-  },
-]);
 
 const FIELD_ALIASES = {
   entityId: [
@@ -260,128 +228,6 @@ function buildRecommendations({ unscopedRecords, crossScopeDuplicates }) {
   return recommendations;
 }
 
-function hasEmbeddingEvidence(record = {}) {
-  return Boolean(
-    record.embedding
-    || record.vector
-    || record.embeddingId
-    || record.metadata?.embedding
-    || record.metadata?.embeddingId
-    || record.metadata?.vectorId
-    || record.semanticKey
-    || record.metadata?.semanticKey
-  );
-}
-
-function hasStructuredFactEvidence(record = {}) {
-  const type = String(record.type || record.kind || record.memoryType || record.metadata?.type || '').toLowerCase();
-  return type === 'fact'
-    || type === 'structured_fact'
-    || Boolean(record.factKey || record.fact || record.metadata?.factKey || record.metadata?.fact);
-}
-
-function hasContextEvidence(record = {}) {
-  return Boolean(
-    record.contextPackId
-    || record.contextPack
-    || record.metadata?.contextPackId
-    || record.metadata?.contextPack
-    || record.retrievalQuery
-    || record.metadata?.retrievalQuery
-  );
-}
-
-function boolCapability(capabilities = {}, ...keys) {
-  return keys.some((key) => capabilities[key] === true);
-}
-
-function buildMemoryOsLayerReport(records = [], capabilities = {}) {
-  const scopeReport = buildMemoryScopeReadinessReport(records);
-  const semanticRecords = records.filter(hasEmbeddingEvidence);
-  const structuredFactRecords = records.filter(hasStructuredFactEvidence);
-  const contextRecords = records.filter(hasContextEvidence);
-  const curationReady = scopeReport.unscopedRecords === 0 && scopeReport.crossScopeDuplicates.length === 0;
-
-  const checks = [
-    {
-      id: 'file_layer',
-      ok: records.length > 0 || boolCapability(capabilities, 'rawStorage', 'fileLayer'),
-      evidence: {
-        records: records.length,
-        durableStore: Boolean(records.length > 0 || capabilities.rawStorage || capabilities.fileLayer),
-      },
-      recommendation: 'Capture raw feedback, action receipts, and tool outcomes before promoting memories.',
-    },
-    {
-      id: 'vector_db_layer',
-      ok: semanticRecords.length > 0 || boolCapability(capabilities, 'semanticSearch', 'vectorDbLayer'),
-      evidence: {
-        semanticRecords: semanticRecords.length,
-        semanticSearch: Boolean(capabilities.semanticSearch || capabilities.vectorDbLayer),
-      },
-      recommendation: 'Index lessons with semantic keys or embeddings so related failures are retrieved before action.',
-    },
-    {
-      id: 'structured_facts_layer',
-      ok: structuredFactRecords.length > 0 || boolCapability(capabilities, 'structuredFacts', 'structuredFactsLayer'),
-      evidence: {
-        structuredFactRecords: structuredFactRecords.length,
-        structuredFacts: Boolean(capabilities.structuredFacts || capabilities.structuredFactsLayer),
-      },
-      recommendation: 'Store confirmed customer, project, policy, and budget facts as typed records, not just prose.',
-    },
-    {
-      id: 'auto_curation_layer',
-      ok: curationReady && boolCapability(capabilities, 'autoCuration', 'dedupe', 'autoCurationLayer'),
-      evidence: {
-        unscopedRecords: scopeReport.unscopedRecords,
-        crossScopeDuplicates: scopeReport.crossScopeDuplicates.length,
-        autoCuration: Boolean(capabilities.autoCuration || capabilities.dedupe || capabilities.autoCurationLayer),
-      },
-      recommendation: 'Run dedupe, contradiction, stale-memory, and scope-isolation checks before memories can become gates.',
-    },
-    {
-      id: 'context_layer',
-      ok: contextRecords.length > 0 || boolCapability(capabilities, 'contextPacks', 'contextLayer', 'scopedRetrieval'),
-      evidence: {
-        contextRecords: contextRecords.length,
-        scopedRetrieval: Boolean(capabilities.contextPacks || capabilities.contextLayer || capabilities.scopedRetrieval),
-      },
-      recommendation: 'Inject scoped context packs per task instead of loading every memory into the model window.',
-    },
-    {
-      id: 'interface_layer',
-      ok: boolCapability(capabilities, 'mcp', 'cli', 'hooks', 'dashboard', 'interfaceLayer'),
-      evidence: {
-        cli: Boolean(capabilities.cli),
-        mcp: Boolean(capabilities.mcp),
-        hooks: Boolean(capabilities.hooks),
-        dashboard: Boolean(capabilities.dashboard),
-      },
-      recommendation: 'Expose the same memory contract through CLI, MCP, hooks, dashboard, and agent adapters.',
-    },
-  ].map((check) => {
-    const layer = MEMORY_OS_LAYERS.find((candidate) => candidate.id === check.id);
-    return {
-      ...layer,
-      ...check,
-    };
-  });
-
-  const missingLayers = checks.filter((check) => !check.ok).map((check) => check.id);
-
-  return {
-    ready: missingLayers.length === 0,
-    riskLevel: missingLayers.length === 0 ? 'low' : missingLayers.length <= 2 ? 'medium' : 'high',
-    layers: checks,
-    missingLayers,
-    scopeReport,
-    recommendations: checks
-      .filter((check) => !check.ok)
-      .map((check) => check.recommendation),
-  };
-}
-
 function selectRecordsForScope(records = [], requestedScope = {}, options = {}) {
   const requested = normalizeScope(requestedScope);
   const requestedKey = memoryScopeKey(requested);
@@ -419,7 +265,6 @@ function buildMemoriStyleBenchmarkRecords() {
       projectId: 'thumbgate',
       processId: 'agent-a',
       sessionId: 'session-1',
-      metadata: { semanticKey: 'checkout-readiness', contextPackId: 'checkout-pro' },
       content: 'Use the paid sprint checklist before changing checkout code.',
     },
     {
@@ -453,18 +298,14 @@ function buildMemoriStyleBenchmarkRecords() {
       processId: 'agent-a',
       sessionId: 'session-1',
       visibility: 'shared',
-      type: 'fact',
-      factKey: 'checkout.mutation_policy',
       content: 'Shared rule: checkout mutations require audit evidence.',
     },
   ];
 }
 
 module.exports = {
-  MEMORY_OS_LAYERS,
   REQUIRED_SCOPE_FIELDS,
   buildMemoriStyleBenchmarkRecords,
-  buildMemoryOsLayerReport,
   buildMemoryScopeReadinessReport,
   isSharedMemory,
   memoryScopeKey,