avorelo 0.1.0

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

@@ -0,0 +1,498 @@
+"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

@@ -0,0 +1,170 @@
+"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,
+};