avorelo 0.1.0 → 0.3.0

package/scripts/lib/orchestration/model-discovery.js

@@ -1,498 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { commandExists } = require("../activation/detect-environment");
-const { readProjectConfig } = require("../config");
-const { buildProfileSummary, detectProfile } = require("./model-profiles");
-const { createModelKey, inferModelRecord, mergeModelRecord } = require("./model-profiler");
-const {
-  INVENTORY_SCHEMA_VERSION,
-  determineRefreshDecision,
-  defaultRefreshPolicy,
-  nextRefreshAfter,
-  tryAcquireRefreshLock,
-  releaseRefreshLock,
-} = require("./model-refresh-policy");
-const {
-  ensureOrchestrationDirs,
-  getCurrentPaths,
-  safeReadJson,
-  writeJson,
-  readLatestRunProofs,
-} = require("./state");
-const claudeCode = require("./provider-discovery/claude-code");
-const codex = require("./provider-discovery/codex");
-const gemini = require("./provider-discovery/gemini");
-const lmStudio = require("./provider-discovery/lm-studio");
-const ollama = require("./provider-discovery/ollama");
-const opencode = require("./provider-discovery/opencode");
-const aider = require("./provider-discovery/aider");
-const openrouter = require("./provider-discovery/openrouter");
-const { envPresence, pathExists, safeReadJsonFile, findFirstModelValue, buildBaseToolRecord } = require("./provider-discovery/common");
-
-const FAILURE_LIMIT = 40;
-
-const PROVIDERS = {
-  claude_code: claudeCode,
-  codex,
-  gemini_cli: gemini,
-  lm_studio: lmStudio,
-  ollama,
-  opencode,
-  aider,
-  openrouter_api: openrouter,
-};
-
-function readFailureState(cwd) {
-  const current = getCurrentPaths(cwd);
-  const payload = safeReadJson(current.workerFailures, { schemaVersion: 1, records: [] });
-  if (!Array.isArray(payload.records)) payload.records = [];
-  return payload;
-}
-
-function writeFailureState(cwd, state) {
-  const current = getCurrentPaths(cwd);
-  writeJson(current.workerFailures, {
-    schemaVersion: 1,
-    records: (state.records || []).slice(-FAILURE_LIMIT),
-  });
-}
-
-function classifyFailureReason(reasonText = "") {
-  const text = String(reasonText || "").toLowerCase();
-  if (/(401|auth|login|credentials|not logged in|sign in)/.test(text)) return { classifiedReason: "needs_login", cooldownMs: null };
-  if (/(429|quota|rate limit|credits exhausted|too many requests|usage limit)/.test(text)) return { classifiedReason: "recently_limited", cooldownMs: 60 * 60 * 1000 };
-  if (/(timeout|timed out|econnrefused|server unavailable|not running)/.test(text)) return { classifiedReason: "recently_failed", cooldownMs: 15 * 60 * 1000 };
-  if (/(model not found|unknown model|no such model)/.test(text)) return { classifiedReason: "stale", cooldownMs: null };
-  if (/(verification failed|verification|tests failed)/.test(text)) return { classifiedReason: "verification_failed", cooldownMs: 15 * 60 * 1000 };
-  return { classifiedReason: "recently_failed", cooldownMs: 15 * 60 * 1000 };
-}
-
-function recordWorkerFailure(cwd, record) {
-  const state = readFailureState(cwd);
-  const classified = classifyFailureReason(record.reason);
-  const observedAt = record.observedAt || new Date().toISOString();
-  const cooldownUntil = classified.cooldownMs ? new Date(Date.parse(observedAt) + classified.cooldownMs).toISOString() : null;
-  state.records.push({
-    workerId: record.workerId,
-    modelId: record.modelId || null,
-    reason: record.reason,
-    classifiedReason: classified.classifiedReason,
-    observedAt,
-    cooldownUntil,
-    taskType: record.taskType || null,
-    risk: record.risk || null,
-  });
-  writeFailureState(cwd, state);
-}
-
-function activeFailures(cwd) {
-  const now = Date.now();
-  return readFailureState(cwd).records.filter((record) => {
-    if (!record.cooldownUntil) return record.classifiedReason === "needs_login" || record.classifiedReason === "stale";
-    const until = Date.parse(record.cooldownUntil);
-    return Number.isFinite(until) && until > now;
-  });
-}
-
-function aggregateRecentHistory(cwd) {
-  const history = {};
-  const proofs = readLatestRunProofs(cwd, 40);
-  proofs.forEach(({ proof }) => {
-    const workers = new Set();
-    (proof?.toolsUsed || []).forEach((worker) => {
-      if (worker && worker.toolId) workers.add(worker.toolId);
-    });
-    workers.forEach((toolId) => {
-      const bucket = history[toolId] || {
-        successes: 0,
-        failures: 0,
-        lastFailureReason: null,
-        recentlyLimited: false,
-        recentlyFailed: false,
-      };
-      if (proof?.finalStatus === "completed" || proof?.finalStatus === "verified") {
-        bucket.successes += 1;
-      } else if (proof?.finalStatus && proof.finalStatus !== "planned" && proof.finalStatus !== "dry_run") {
-        bucket.failures += 1;
-        bucket.recentlyFailed = true;
-        if (proof?.failureReason) bucket.lastFailureReason = proof.failureReason;
-      }
-      if ((proof?.failures || []).some((entry) => /limit/i.test(String(entry.reason || "")))) {
-        bucket.recentlyLimited = true;
-      }
-      history[toolId] = bucket;
-    });
-  });
-
-  activeFailures(cwd).forEach((record) => {
-    const bucket = history[record.workerId] || {
-      successes: 0,
-      failures: 0,
-      lastFailureReason: null,
-      recentlyLimited: false,
-      recentlyFailed: false,
-    };
-    bucket.failures += 1;
-    bucket.lastFailureReason = record.reason;
-    if (record.classifiedReason === "recently_limited") bucket.recentlyLimited = true;
-    if (record.classifiedReason === "recently_failed" || record.classifiedReason === "verification_failed") bucket.recentlyFailed = true;
-    history[record.workerId] = bucket;
-  });
-  return history;
-}
-
-function deriveWorkerState(base, enabled) {
-  if (enabled === false) return "disabled_by_user";
-  if (base.availability === "needs_login") return "needs_login";
-  if (base.recentHistory?.recentlyLimited) return "recently_limited";
-  if (base.recentHistory?.recentlyFailed) return "recently_failed";
-  if (base.installStatus === "not_installed") return "missing";
-  if (base.installStatus === "installed_not_on_path") return "installed_not_on_path";
-  if (base.availability === "confirmed") return "available";
-  if (base.availability === "configured") return "configured";
-  return "unknown";
-}
-
-function applyHistoryAndSettings(tool, config, history, failureRecords) {
-  const enabled = config.orchestration?.allowedWorkers?.[tool.toolId] !== false;
-  const recentHistory = history[tool.toolId] || tool.recentHistory || {
-    successes: 0,
-    failures: 0,
-    lastFailureReason: null,
-    recentlyLimited: false,
-    recentlyFailed: false,
-  };
-  const activeForTool = failureRecords.filter((record) => record.workerId === tool.toolId);
-  const nextModels = (tool.models || []).map((model) => {
-    const matchedFailure = activeForTool.find((record) => !record.modelId || record.modelId === model.modelId);
-    if (!matchedFailure) return model;
-    return {
-      ...model,
-      availability: matchedFailure.classifiedReason,
-      lastFailure: matchedFailure,
-      recentFailureScore: Number(model.recentFailureScore || 0) + 1,
-      lastCheckedAt: matchedFailure.observedAt,
-    };
-  });
-  let availability = tool.availability;
-  if (recentHistory.recentlyLimited && availability !== "needs_login") availability = "recently_limited";
-  if (recentHistory.recentlyFailed && !["needs_login", "recently_limited"].includes(availability)) availability = "recently_failed";
-  const workerState = deriveWorkerState({ ...tool, availability, recentHistory }, enabled);
-
-  return {
-    ...tool,
-    availability,
-    activeProfile: detectProfile(tool.toolId, tool.activeModel)?.id || tool.activeProfile || null,
-    models: nextModels,
-    availableModels: nextModels.map((model) => ({ id: model.modelId, availability: model.availability })),
-    candidateProfiles: buildProfileSummary(tool.toolId, tool.activeModel),
-    recentHistory,
-    lastFailureReason: recentHistory.lastFailureReason || null,
-    workerState,
-    enabled,
-  };
-}
-
-function discoverGenericTools(cwd, context = {}) {
-  const env = context.env || process.env;
-  const exists = context.commandExists || commandExists;
-  const packageJson = safeReadJsonFile(path.join(cwd, "package.json")) || {};
-  const scripts = packageJson.scripts || {};
-  const testScripts = ["test", "build", "lint", "typecheck"].filter((name) => typeof scripts[name] === "string");
-  const generic = [];
-
-  generic.push(buildBaseToolRecord({
-    toolId: "test_runner",
-    label: "Local test runner",
-    providerId: "local",
-    installStatus: testScripts.length > 0 ? "configured" : "available",
-    availability: testScripts.length > 0 ? "confirmed" : "configured",
-    supportedRoles: ["verify"],
-    costTier: "free_local",
-    qualityTier: "highest",
-    trustTier: "local",
-    privacyTier: "local_only",
-    latencyTier: "medium",
-    executionMode: "direct",
-    details: { packageScripts: testScripts },
-    safeForHighRisk: true,
-  }));
-
-  generic.push(buildBaseToolRecord({
-    toolId: "git",
-    label: "Git",
-    providerId: "local",
-    installStatus: exists("git", env) ? "configured" : "not_installed",
-    availability: exists("git", env) ? "confirmed" : "unavailable",
-    supportedRoles: ["status", "diff", "proof", "verify"],
-    costTier: "free_local",
-    qualityTier: "highest",
-    trustTier: "local",
-    privacyTier: "local_only",
-    latencyTier: "fast",
-    executionMode: "direct",
-    safeForHighRisk: true,
-  }));
-
-  const litellmFiles = [
-    "litellm.config.yaml",
-    "litellm.config.yml",
-    ".litellm.json",
-    "requesty.config.json",
-  ].filter((relPath) => fs.existsSync(path.join(cwd, relPath)));
-  const litellmModel = env.LITELLM_MODEL || env.REQUESTY_MODEL || null;
-  const litellmModels = litellmModel ? [
-    inferModelRecord({
-      toolId: "litellm_requesty",
-      providerId: "gateway",
-      modelId: litellmModel,
-      availability: "configured",
-      source: env.LITELLM_MODEL || env.REQUESTY_MODEL ? "env" : "config",
-      trustTier: "unknown",
-      privacyTier: "gateway_remote",
-      confidence: "low",
-    }),
-  ] : [];
-  generic.push(buildBaseToolRecord({
-    toolId: "litellm_requesty",
-    label: "LiteLLM / Requesty",
-    providerId: "gateway",
-    installStatus: litellmFiles.length > 0 || envPresence(env, "LITELLM_MODEL") || envPresence(env, "REQUESTY_MODEL") ? "configured" : "not_installed",
-    availability: litellmFiles.length > 0 || envPresence(env, "LITELLM_MODEL") || envPresence(env, "REQUESTY_MODEL") ? "configured" : "unavailable",
-    activeModel: litellmModel,
-    configuredModelSource: env.LITELLM_MODEL ? "env:LITELLM_MODEL" : (env.REQUESTY_MODEL ? "env:REQUESTY_MODEL" : null),
-    models: litellmModels,
-    supportedRoles: ["planning", "implementation", "docs", "tests"],
-    costTier: "medium",
-    qualityTier: "unknown",
-    trustTier: "unknown",
-    privacyTier: "gateway_remote",
-    latencyTier: "medium",
-    details: {
-      configFiles: litellmFiles,
-      gatewayKeyPresent: envPresence(env, "LITELLM_API_KEY") || envPresence(env, "REQUESTY_API_KEY"),
-    },
-  }));
-
-  return generic;
-}
-
-function observedModelCandidates(cwd, options = {}) {
-  const env = options.env || process.env;
-  const candidates = [];
-  const map = [
-    ["CODEX_MODEL", "codex", "openai"],
-    ["OPENAI_MODEL", "codex", "openai"],
-    ["ANTHROPIC_MODEL", "claude_code", "anthropic"],
-    ["GEMINI_MODEL", "gemini_cli", "google"],
-    ["OPENCODE_MODEL", "opencode", options.env?.OPENCODE_PROVIDER || "opencode"],
-    ["AIDER_MODEL", "aider", "aider"],
-    ["OLLAMA_MODEL", "ollama", "local"],
-    ["LM_STUDIO_MODEL", "lm_studio", "local"],
-    ["LMSTUDIO_MODEL", "lm_studio", "local"],
-  ];
-  map.forEach(([name, toolId, providerId]) => {
-    if (env[name]) candidates.push({ toolId, providerId, modelId: env[name], source: `env:${name}` });
-  });
-
-  const claudeSettings = safeReadJsonFile(path.join(cwd, ".claude", "settings.json"));
-  const claudeLocalSettings = safeReadJsonFile(path.join(cwd, ".claude", "settings.local.json"));
-  const codexSettings = safeReadJsonFile(path.join(cwd, ".codex", "config.json")) || safeReadJsonFile(path.join(cwd, ".codex", "settings.json"));
-  const opencodeSettings = safeReadJsonFile(path.join(cwd, ".opencode", "config.json"));
-  const aiderSettings = safeReadJsonFile(path.join(cwd, ".aider.model.settings.json"));
-  const configFiles = [
-    [findFirstModelValue(claudeLocalSettings) || findFirstModelValue(claudeSettings), "claude_code", "anthropic", "config"],
-    [findFirstModelValue(codexSettings), "codex", "openai", "config"],
-    [findFirstModelValue(opencodeSettings), "opencode", "opencode", "config"],
-    [findFirstModelValue(aiderSettings), "aider", "aider", "config"],
-  ];
-  configFiles.forEach(([modelId, toolId, providerId, source]) => {
-    if (modelId) candidates.push({ toolId, providerId, modelId, source });
-  });
-
-  const proofs = readLatestRunProofs(cwd, 20);
-  proofs.forEach(({ proof }) => {
-    (proof?.toolsUsed || []).forEach((tool) => {
-      const modelId = tool.actualModelUsed || tool.selectedModel || tool.activeModel || tool.modelId || null;
-      const providerId = tool.providerId || tool.provider || "unknown";
-      if (tool.toolId && modelId) {
-        candidates.push({ toolId: tool.toolId, providerId, modelId, source: "observed_usage" });
-      }
-    });
-  });
-
-  return candidates;
-}
-
-function mergeObservedModels(inventory, observed, reason = "new_model_observed") {
-  const next = { ...inventory, tools: (inventory.tools || []).map((tool) => ({ ...tool, models: (tool.models || []).slice() })) };
-  const existingKeys = new Set(next.knownModelKeys || []);
-  let changed = false;
-  observed.forEach((candidate) => {
-    const key = createModelKey(candidate.toolId, candidate.providerId, candidate.modelId);
-    if (existingKeys.has(key)) return;
-    const tool = next.tools.find((entry) => entry.toolId === candidate.toolId);
-    if (!tool) return;
-    tool.models = tool.models || [];
-    const inferred = inferModelRecord({
-      toolId: candidate.toolId,
-      providerId: candidate.providerId,
-      modelId: candidate.modelId,
-      availability: "candidate",
-      source: candidate.source || "observed_usage",
-      trustTier: tool.trustTier,
-      privacyTier: tool.privacyTier,
-      confidence: "low",
-      metadata: { notes: [reason] },
-    });
-    tool.models.push(inferred);
-    tool.availableModels = tool.models.map((model) => ({ id: model.modelId, availability: model.availability }));
-    if (!tool.activeModel) tool.activeModel = candidate.modelId;
-    existingKeys.add(key);
-    changed = true;
-  });
-  if (changed) {
-    next.knownModelKeys = Array.from(existingKeys).sort();
-    next.lastRefreshReason = reason;
-    next.refreshLevel = "single_model";
-    next.inventorySource = "partial";
-  }
-  return { inventory: next, changed };
-}
-
-function discoverToolSet(cwd, options = {}) {
-  const context = {
-    env: options.env || process.env,
-    commandExists: options.commandExists || commandExists,
-    commandRunner: options.commandRunner,
-    httpGetJson: options.httpGetJson,
-    surface: options.surface || "avorelo_cli",
-    homeDir: options.homeDir,
-    refreshLevel: options.refreshLevel || "full",
-    tryNativeLmStudio: options.deepRefresh === true,
-  };
-  const tools = [
-    claudeCode.discover(cwd, context),
-    codex.discover(cwd, context),
-    gemini.discover(cwd, context),
-    lmStudio.discover(cwd, context),
-    opencode.discover(cwd, context),
-    aider.discover(cwd, context),
-    ollama.discover(cwd, context),
-    openrouter.discover(cwd, context),
-    ...discoverGenericTools(cwd, context),
-  ];
-  return tools;
-}
-
-function buildInventory(cwd, options = {}) {
-  ensureOrchestrationDirs(cwd);
-  const config = options.config || readProjectConfig(cwd);
-  const history = aggregateRecentHistory(cwd);
-  const failures = activeFailures(cwd);
-  const tools = discoverToolSet(cwd, options).map((tool) => applyHistoryAndSettings(tool, config, history, failures));
-  const policy = defaultRefreshPolicy(config.orchestration);
-  const now = new Date().toISOString();
-  const knownModelKeys = tools.flatMap((tool) => (tool.models || []).map((model) => createModelKey(tool.toolId, model.providerId, model.modelId)));
-  return {
-    schemaVersion: INVENTORY_SCHEMA_VERSION,
-    generatedAt: now,
-    lastFullModelRefreshAt: now,
-    nextFullModelRefreshAfter: nextRefreshAfter(now, policy),
-    refreshPolicy: policy,
-    knownModelKeys: Array.from(new Set(knownModelKeys)).sort(),
-    lastRefreshReason: options.lastRefreshReason || "explicit_refresh",
-    refreshLevel: options.refreshLevel || "full",
-    inventorySource: options.inventorySource || "rebuilt",
-    cwd,
-    tools,
-  };
-}
-
-function rehydrateCachedInventory(cwd, cached, config) {
-  const history = aggregateRecentHistory(cwd);
-  const failures = activeFailures(cwd);
-  return {
-    ...cached,
-    tools: (cached.tools || []).map((tool) => applyHistoryAndSettings(tool, config, history, failures)),
-  };
-}
-
-function discoverInventory(cwd, options = {}) {
-  const config = options.config || readProjectConfig(cwd);
-  const current = getCurrentPaths(cwd);
-  const cached = safeReadJson(current.inventory, null);
-  const refresh = determineRefreshDecision(cached, config.orchestration, options);
-  const observed = observedModelCandidates(cwd, options);
-
-  if (refresh.refreshLevel === "cache" && cached) {
-    const rehydrated = rehydrateCachedInventory(cwd, cached, config);
-    rehydrated.inventorySource = "cache";
-    rehydrated.refreshLevel = "cache";
-    const merged = mergeObservedModels(rehydrated, observed);
-    if (merged.changed && refresh.policy.singleModelRefreshOnNewUsage) {
-      const changedToolIds = new Set((merged.inventory.tools || []).flatMap((tool) => (tool.models || []).filter((model) => (model.notes || []).includes("new_model_observed")).map(() => tool.toolId)));
-      if (changedToolIds.size > 0) {
-        const lock = tryAcquireRefreshLock(cwd);
-        if (lock.ok) {
-          try {
-            const rebuilt = buildInventory(cwd, {
-              ...options,
-              refreshLevel: "single_model",
-              inventorySource: "partial",
-              lastRefreshReason: "new_model_observed",
-            });
-            const hydrated = mergeObservedModels(rebuilt, observed).inventory;
-            writeJson(current.inventory, hydrated);
-            return hydrated;
-          } finally {
-            releaseRefreshLock(cwd);
-          }
-        }
-      }
-    }
-    if (merged.changed || JSON.stringify(rehydrated) !== JSON.stringify(cached)) writeJson(current.inventory, merged.inventory);
-    return merged.inventory;
-  }
-
-  const lock = tryAcquireRefreshLock(cwd);
-  if (!lock.ok && cached) return cached;
-  try {
-    const inventory = buildInventory(cwd, {
-      ...options,
-      refreshLevel: refresh.refreshLevel,
-      inventorySource: refresh.inventorySource,
-      lastRefreshReason: refresh.lastRefreshReason,
-    });
-    const finalInventory = mergeObservedModels(inventory, observed, refresh.lastRefreshReason === "explicit_refresh" ? "new_model_observed" : refresh.lastRefreshReason).inventory;
-    writeJson(current.inventory, finalInventory);
-    return finalInventory;
-  } finally {
-    releaseRefreshLock(cwd);
-  }
-}
-
-function summarizeInventoryForText(inventory) {
-  const tools = Array.isArray(inventory?.tools) ? inventory.tools : [];
-  return {
-    total: tools.length,
-    available: tools.filter((tool) => ["confirmed", "configured", "recently_failed", "recently_limited", "needs_login"].includes(tool.availability)).length,
-    enabled: tools.filter((tool) => tool.enabled).length,
-  };
-}
-
-function loadInventory(cwd, options = {}) {
-  return discoverInventory(cwd, options);
-}
-
-module.exports = {
-  INVENTORY_SCHEMA_VERSION,
-  loadInventory,
-  discoverInventory,
-  summarizeInventoryForText,
-  recordWorkerFailure,
-  classifyFailureReason,
-  mergeObservedModels,
-};

package/scripts/lib/orchestration/model-profiler.js

@@ -1,170 +0,0 @@
-"use strict";
-
-function normalizeModelId(value) {
-  return String(value || "").trim();
-}
-
-function normalizeModelIdLower(value) {
-  return normalizeModelId(value).toLowerCase();
-}
-
-function createModelKey(toolId, providerId, modelId) {
-  return `${toolId}:${providerId}:${modelId}`;
-}
-
-function inferProfilesFromModelId(modelId, displayName = "", metadata = {}) {
-  const text = `${modelId || ""} ${displayName || ""} ${metadata.family || ""} ${(metadata.families || []).join(" ")}`.toLowerCase();
-  const profiles = new Set();
-
-  if (/(mini|flash|lite|small|nano)/i.test(text)) profiles.add("fast_low_cost");
-  if (/(pro|sonnet|default)/i.test(text)) profiles.add("standard_quality");
-  if (/(opus|deep|reasoning|thinking|high|5\.5|xhigh)/i.test(text)) profiles.add("deep_reasoning");
-  if (/(coder|code|codestral|devstral|qwen-coder|deepseek-coder|codellama|starcoder|deepseek|qwen)/i.test(text)) profiles.add("coding_candidate");
-  if (/(embedding|embed)/i.test(text)) profiles.add("not_chat_worker");
-  if (/(vision|multimodal|vl)/i.test(text)) profiles.add("vision_capable");
-  if (/(instruct|chat)/i.test(text)) profiles.add("chat_candidate");
-
-  return Array.from(profiles);
-}
-
-function inferContextTier(metadata = {}) {
-  const context = Number(metadata.contextWindow || metadata.context_length || metadata.max_context || 0);
-  if (!Number.isFinite(context) || context <= 0) return "unknown";
-  if (context < 16000) return "small";
-  if (context < 64000) return "medium";
-  if (context < 200000) return "large";
-  return "very_large";
-}
-
-function inferLatencyTier({ providerId, modelId }) {
-  const text = normalizeModelIdLower(modelId);
-  if (providerId === "local") return "fast";
-  if (/(mini|flash|lite|small|nano)/.test(text)) return "fast";
-  if (/(opus|deep|reasoning|thinking|5\.5|xhigh)/.test(text)) return "slow";
-  if (!text) return "unknown";
-  return "medium";
-}
-
-function inferCostTier({ providerId, profiles = [], trustedRemote = false }) {
-  if (providerId === "local" || providerId === "ollama" || providerId === "lm_studio") return "free_local";
-  if (profiles.includes("fast_low_cost")) return "low";
-  if (profiles.includes("deep_reasoning")) return "high";
-  if (trustedRemote) return "medium";
-  return "unknown";
-}
-
-function inferQualityTier({ profiles = [], providerId }) {
-  if (profiles.includes("deep_reasoning")) return "highest";
-  if (profiles.includes("standard_quality")) return "high";
-  if (profiles.includes("fast_low_cost")) return "medium";
-  if (providerId === "local") return "unknown";
-  return "unknown";
-}
-
-function defaultRolesForProfiles({ profiles = [], trustTier, privacyTier }) {
-  if (profiles.includes("not_chat_worker")) return [];
-
-  const roles = new Set(["planning", "summaries", "docs"]);
-  if (profiles.includes("chat_candidate")) roles.add("planning");
-  if (profiles.includes("coding_candidate")) roles.add("cheap_build");
-  if (privacyTier === "local_only") roles.add("local_private");
-  if (trustTier === "trusted" || trustTier === "local") roles.add("repo_reading");
-  return Array.from(roles);
-}
-
-function inferModelRecord({
-  toolId,
-  providerId,
-  modelId,
-  displayName = null,
-  availability = "candidate",
-  source = "inferred",
-  trustTier = "unknown",
-  privacyTier = "unknown",
-  metadata = {},
-  confidence = "low",
-  observedAt = null,
-}) {
-  const normalized = normalizeModelId(modelId);
-  const firstSeenAt = observedAt || new Date().toISOString();
-  const profiles = inferProfilesFromModelId(normalized, displayName, metadata);
-  const localLike = trustTier === "local" || privacyTier === "local_only";
-  const trustedRemote = trustTier === "trusted";
-  const costTier = inferCostTier({ providerId, profiles, trustedRemote });
-  const qualityTier = inferQualityTier({ profiles, providerId });
-  const safeForHighRisk = Boolean(
-    !profiles.includes("not_chat_worker")
-    && (trustTier === "local" || (trustTier === "trusted" && privacyTier === "trusted_remote"))
-    && availability === "confirmed"
-    && confidence !== "low"
-    && !profiles.includes("fast_low_cost")
-  );
-
-  return {
-    toolId,
-    providerId,
-    modelId: normalized,
-    displayName: displayName || normalized,
-    availability,
-    source,
-    profiles,
-    costTier,
-    qualityTier,
-    trustTier,
-    privacyTier,
-    latencyTier: inferLatencyTier({ providerId, modelId: normalized }),
-    contextTier: inferContextTier(metadata),
-    supportsTools: metadata.supportsTools === true,
-    supportsStructuredOutput: metadata.supportsStructuredOutput === true,
-    supportsVision: profiles.includes("vision_capable") || metadata.supportsVision === true,
-    supportsReasoning: profiles.includes("deep_reasoning") || metadata.supportsReasoning === true,
-    safeForHighRisk,
-    confidence,
-    firstSeenAt,
-    lastSeenAt: firstSeenAt,
-    lastCheckedAt: firstSeenAt,
-    lastFailure: null,
-    recentSuccessScore: 0,
-    recentFailureScore: 0,
-    notes: metadata.notes || [],
-    roles: defaultRolesForProfiles({ profiles, trustTier: localLike ? "local" : trustTier, privacyTier }),
-  };
-}
-
-function mergeModelRecord(previous, next) {
-  if (!previous) return next;
-  return {
-    ...previous,
-    ...next,
-    firstSeenAt: previous.firstSeenAt || next.firstSeenAt,
-    lastSeenAt: next.lastSeenAt || previous.lastSeenAt,
-    lastCheckedAt: next.lastCheckedAt || previous.lastCheckedAt,
-    profiles: Array.from(new Set([...(previous.profiles || []), ...(next.profiles || [])])),
-    roles: Array.from(new Set([...(previous.roles || []), ...(next.roles || [])])),
-    notes: Array.from(new Set([...(previous.notes || []), ...(next.notes || [])])),
-    recentSuccessScore: Number(previous.recentSuccessScore || 0) + Number(next.recentSuccessScore || 0),
-    recentFailureScore: Number(previous.recentFailureScore || 0) + Number(next.recentFailureScore || 0),
-    lastFailure: next.lastFailure || previous.lastFailure || null,
-  };
-}
-
-function buildProfileSummary(toolId, activeModel) {
-  const modelId = normalizeModelId(activeModel);
-  if (!modelId) return [];
-  return inferProfilesFromModelId(modelId).map((profileId) => ({
-    id: profileId,
-    provider: toolId,
-    label: profileId.replace(/_/g, " "),
-    availability: "confirmed",
-  }));
-}
-
-module.exports = {
-  normalizeModelId,
-  normalizeModelIdLower,
-  createModelKey,
-  inferProfilesFromModelId,
-  inferModelRecord,
-  mergeModelRecord,
-  buildProfileSummary,
-};