avorelo 0.1.0 → 0.2.0

package/scripts/lib/orchestration/provider-discovery/aider.js

@@ -1,49 +0,0 @@
-"use strict";
-
-const path = require("path");
-const { inferModelRecord } = require("../model-profiler");
-const { buildBaseToolRecord, envPresence, pathExists } = require("./common");
-
-function discover(cwd, context = {}) {
-  const env = context.env || process.env;
-  const exists = context.commandExists;
-  const activeModel = env.AIDER_MODEL || null;
-  const installStatus = exists("aider", env)
-    || pathExists(path.join(cwd, ".aider.conf.yml"))
-    || pathExists(path.join(cwd, ".aider.model.settings.yml"))
-    || envPresence(env, "AIDER_MODEL")
-    ? "configured"
-    : "not_installed";
-  const availability = installStatus === "configured" ? "configured" : "unavailable";
-  const models = activeModel ? [
-    inferModelRecord({
-      toolId: "aider",
-      providerId: "aider",
-      modelId: activeModel,
-      availability: "configured",
-      source: env.AIDER_MODEL ? "env" : "inferred",
-      trustTier: "external",
-      privacyTier: "external_remote",
-      confidence: "low",
-    }),
-  ] : [];
-
-  return buildBaseToolRecord({
-    toolId: "aider",
-    label: "Aider",
-    providerId: "aider",
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource: env.AIDER_MODEL ? "env:AIDER_MODEL" : null,
-    models,
-    supportedRoles: ["implementation", "refactor", "tests", "cli"],
-    costTier: "medium",
-    qualityTier: "high",
-    trustTier: "external",
-    privacyTier: "external_remote",
-    latencyTier: "medium",
-  });
-}
-
-module.exports = { discover };

package/scripts/lib/orchestration/provider-discovery/claude-code.js

@@ -1,56 +0,0 @@
-"use strict";
-
-const path = require("path");
-const { inferModelRecord } = require("../model-profiler");
-const { buildBaseToolRecord, envPresence, safeReadJsonFile, findFirstModelValue, pathExists } = require("./common");
-
-function discover(cwd, context = {}) {
-  const env = context.env || process.env;
-  const settings = safeReadJsonFile(path.join(cwd, ".claude", "settings.json"));
-  const localSettings = safeReadJsonFile(path.join(cwd, ".claude", "settings.local.json"));
-  const activeModel = env.ANTHROPIC_MODEL || findFirstModelValue(localSettings) || findFirstModelValue(settings) || null;
-  const baseUrl = env.ANTHROPIC_BASE_URL || null;
-  const gateway = Boolean(baseUrl && !/anthropic\.com/i.test(baseUrl));
-  const installStatus = pathExists(path.join(cwd, ".claude")) || pathExists(path.join(cwd, ".claude-plugin")) ? "configured" : "not_installed";
-  const availability = installStatus === "configured" || envPresence(env, "ANTHROPIC_AUTH_TOKEN") ? "configured" : "unavailable";
-  const models = activeModel ? [
-    inferModelRecord({
-      toolId: "claude_code",
-      providerId: gateway ? "gateway" : "anthropic",
-      modelId: activeModel,
-      displayName: activeModel,
-      availability: availability === "configured" ? "configured" : "unavailable",
-      source: env.ANTHROPIC_MODEL ? "env" : (localSettings ? "config" : "inferred"),
-      trustTier: gateway ? "unknown" : "trusted",
-      privacyTier: gateway ? "gateway_remote" : "trusted_remote",
-      confidence: "medium",
-    }),
-  ] : [];
-
-  return buildBaseToolRecord({
-    toolId: "claude_code",
-    label: "Claude Code",
-    providerId: gateway ? "gateway" : "anthropic",
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource: env.ANTHROPIC_MODEL ? "env:ANTHROPIC_MODEL" : (localSettings ? ".claude/settings.local.json" : (settings ? ".claude/settings.json" : null)),
-    models,
-    supportedRoles: ["planning", "implementation", "review", "security", "tests", "docs", "ui", "cli"],
-    costTier: "high",
-    qualityTier: "high",
-    trustTier: gateway ? "unknown" : "trusted",
-    privacyTier: gateway ? "gateway_remote" : "trusted_remote",
-    latencyTier: "medium",
-    executionMode: context.surface === "claude_code" ? "in_session" : "handoff",
-    details: {
-      settingsPresent: Boolean(settings),
-      localSettingsPresent: Boolean(localSettings),
-      anthropicBaseUrlPresent: Boolean(baseUrl),
-      anthropicGatewayConfigured: gateway,
-      anthropicAuthTokenPresent: envPresence(env, "ANTHROPIC_AUTH_TOKEN"),
-    },
-  });
-}
-
-module.exports = { discover };

package/scripts/lib/orchestration/provider-discovery/codex.js

@@ -1,49 +0,0 @@
-"use strict";
-
-const { inferModelRecord } = require("../model-profiler");
-const { buildBaseToolRecord, envPresence, pathExists } = require("./common");
-
-function discover(cwd, context = {}) {
-  const env = context.env || process.env;
-  const exists = context.commandExists;
-  const activeModel = env.CODEX_MODEL || env.OPENAI_MODEL || null;
-  const installStatus = exists("codex", env) || pathExists(require("path").join(cwd, ".codex")) || envPresence(env, "CODEX_HOME") ? "configured" : "not_installed";
-  const availability = installStatus === "configured" || envPresence(env, "OPENAI_API_KEY") ? "confirmed" : "unavailable";
-  const models = activeModel ? [
-    inferModelRecord({
-      toolId: "codex",
-      providerId: "openai",
-      modelId: activeModel,
-      displayName: activeModel,
-      availability: availability === "confirmed" ? "confirmed" : "configured",
-      source: env.CODEX_MODEL || env.OPENAI_MODEL ? "env" : "inferred",
-      trustTier: "trusted",
-      privacyTier: "trusted_remote",
-      confidence: "high",
-    }),
-  ] : [];
-  return buildBaseToolRecord({
-    toolId: "codex",
-    label: "Codex / OpenAI CLI",
-    providerId: "openai",
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource: env.CODEX_MODEL ? "env:CODEX_MODEL" : (env.OPENAI_MODEL ? "env:OPENAI_MODEL" : null),
-    models,
-    supportedRoles: ["planning", "implementation", "review", "tests", "refactor", "ui", "cli", "docs"],
-    costTier: "medium",
-    qualityTier: "high",
-    trustTier: "trusted",
-    privacyTier: "trusted_remote",
-    latencyTier: "medium",
-    executionMode: context.surface === "codex_cli" ? "in_session" : "handoff",
-    details: {
-      codexHomePresent: envPresence(env, "CODEX_HOME"),
-      openAiApiKeyPresent: envPresence(env, "OPENAI_API_KEY"),
-    },
-    safeForHighRisk: true,
-  });
-}
-
-module.exports = { discover };

package/scripts/lib/orchestration/provider-discovery/common.js

@@ -1,186 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-const LOCAL_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
-
-function envPresence(env, name) {
-  return Boolean(env && Object.prototype.hasOwnProperty.call(env, name) && env[name]);
-}
-
-function pathExists(absPath) {
-  try {
-    return Boolean(absPath && fs.existsSync(absPath));
-  } catch {
-    return false;
-  }
-}
-
-function safeReadJsonFile(absPath) {
-  try {
-    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^\uFEFF/, ""));
-  } catch {
-    return null;
-  }
-}
-
-function safeReadText(absPath) {
-  try {
-    return fs.readFileSync(absPath, "utf8");
-  } catch {
-    return null;
-  }
-}
-
-function safeHomeDir(options = {}) {
-  return options.homeDir || process.env.USERPROFILE || process.env.HOME || os.homedir() || "";
-}
-
-function parseCommandText(result) {
-  return `${String(result?.stdout || "")}\n${String(result?.stderr || "")}`.trim();
-}
-
-function runCommand(commandName, args, options = {}) {
-  const runner = options.commandRunner;
-  if (typeof runner === "function") return runner(commandName, args, options);
-  return spawnSync(commandName, args, {
-    cwd: options.cwd,
-    env: options.env,
-    encoding: "utf8",
-    timeout: options.timeoutMs || 1500,
-  });
-}
-
-function readLocalJson(url, options = {}) {
-  if (typeof options.httpGetJson === "function") {
-    return options.httpGetJson(url, options);
-  }
-
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return { ok: false, error: "invalid_url" };
-  }
-  if (!LOCAL_HOSTS.has(parsed.hostname)) return { ok: false, error: "non_local_url_blocked" };
-
-  const script = [
-    "const target = process.argv[1];",
-    "const { URL } = require('url');",
-    "const http = require('http');",
-    "const https = require('https');",
-    "let parsed;",
-    "try { parsed = new URL(target); } catch { process.stdout.write(JSON.stringify({ ok:false, error:'invalid_url' })); process.exit(0); }",
-    "const client = parsed.protocol === 'https:' ? https : http;",
-    "const req = client.request(parsed, { method: 'GET', timeout: 1200 }, (res) => {",
-    "  let body = '';",
-    "  res.on('data', (chunk) => { body += String(chunk || ''); });",
-    "  res.on('end', () => {",
-    "    try { process.stdout.write(JSON.stringify({ ok:true, statusCode:res.statusCode || 0, body: JSON.parse(body || '{}') })); }",
-    "    catch { process.stdout.write(JSON.stringify({ ok:false, statusCode:res.statusCode || 0, error:'invalid_json' })); }",
-    "  });",
-    "});",
-    "req.on('timeout', () => { req.destroy(new Error('timeout')); });",
-    "req.on('error', (error) => { process.stdout.write(JSON.stringify({ ok:false, error:String(error && error.message || error || 'request_failed') })); });",
-    "req.end();",
-  ].join("");
-
-  const result = spawnSync(process.execPath, ["-e", script, url], {
-    cwd: options.cwd,
-    env: options.env,
-    encoding: "utf8",
-    timeout: options.timeoutMs || 1800,
-  });
-  try {
-    return JSON.parse(String(result.stdout || "").trim() || "{}");
-  } catch {
-    return { ok: false, error: parseCommandText(result) || "request_failed" };
-  }
-}
-
-function findFirstModelValue(input) {
-  const seen = new Set();
-  const queue = [input];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || typeof current !== "object" || seen.has(current)) continue;
-    seen.add(current);
-    if (Array.isArray(current)) {
-      current.forEach((item) => queue.push(item));
-      continue;
-    }
-    for (const [key, value] of Object.entries(current)) {
-      if (/model/i.test(key) && typeof value === "string" && value.trim()) return value.trim();
-      if (value && typeof value === "object") queue.push(value);
-    }
-  }
-  return null;
-}
-
-function buildBaseToolRecord({
-  toolId,
-  label,
-  providerId,
-  installStatus = "not_installed",
-  availability = "unavailable",
-  activeModel = null,
-  configuredModelSource = null,
-  models = [],
-  supportedRoles = [],
-  costTier = "unknown",
-  qualityTier = "unknown",
-  trustTier = "unknown",
-  privacyTier = "unknown",
-  latencyTier = "unknown",
-  quotaSignal = "unknown",
-  quotaVisibility = "unknown",
-  executionMode = "handoff",
-  details = {},
-  safeForHighRisk = false,
-}) {
-  return {
-    schemaVersion: 2,
-    toolId,
-    label,
-    providerId,
-    provider: providerId,
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource,
-    models,
-    availableModels: models.map((model) => ({ id: model.modelId, availability: model.availability })),
-    candidateProfiles: [],
-    quotaVisibility,
-    quotaSignal,
-    costTier,
-    qualityTier,
-    trustTier,
-    privacyTier,
-    latencyTier,
-    supportedRoles,
-    recentHistory: { successes: 0, failures: 0, lastFailureReason: null, recentlyLimited: false, recentlyFailed: false },
-    lastFailureReason: null,
-    workerState: "unknown",
-    enabled: true,
-    safeForHighRisk,
-    executionMode,
-    details,
-  };
-}
-
-module.exports = {
-  envPresence,
-  pathExists,
-  safeReadJsonFile,
-  safeReadText,
-  safeHomeDir,
-  parseCommandText,
-  runCommand,
-  readLocalJson,
-  findFirstModelValue,
-  buildBaseToolRecord,
-};

package/scripts/lib/orchestration/provider-discovery/gemini.js

@@ -1,106 +0,0 @@
-"use strict";
-
-const path = require("path");
-const { inferModelRecord } = require("../model-profiler");
-const { buildBaseToolRecord, envPresence, safeHomeDir, pathExists, runCommand, parseCommandText } = require("./common");
-
-const LOGIN_PATTERNS = /(login|log in|sign in|authenticate|authentication required|not logged in|credentials required)/i;
-const LIMIT_PATTERNS = /(quota|rate limit|credits exhausted|usage limit|too many requests)/i;
-
-function installSignals(env, options = {}) {
-  const homeDir = safeHomeDir(options);
-  const npmRoot = path.join(homeDir, "AppData", "Roaming", "npm");
-  return {
-    homeConfigPresent: pathExists(path.join(homeDir, ".gemini")),
-    npmPackagePresent: pathExists(path.join(npmRoot, "node_modules", "@google", "gemini-cli")) || pathExists(path.join(npmRoot, "node_modules", "gemini-cli")),
-    envConfigured: envPresence(env, "GEMINI_API_KEY"),
-  };
-}
-
-function discover(cwd, context = {}) {
-  const env = context.env || process.env;
-  const exists = context.commandExists;
-  const signals = installSignals(env, context);
-  const commandPresent = exists("gemini", env) || exists("gemini-cli", env);
-  const activeModel = env.GEMINI_MODEL || null;
-  let installStatus = "not_installed";
-  let availability = "unavailable";
-  let loginProfile = signals.envConfigured ? "api" : "cli_login_or_unknown";
-  let probeReason = "command_missing";
-  let quotaSignal = "unknown";
-
-  if (commandPresent) {
-    const result = runCommand("gemini", ["--version"], {
-      cwd,
-      env,
-      timeoutMs: 1200,
-      commandRunner: context.commandRunner,
-    });
-    const output = parseCommandText(result);
-    if (Number(result?.status) === 0) {
-      installStatus = "configured";
-      availability = "confirmed";
-      probeReason = "version_ok";
-    } else if (LOGIN_PATTERNS.test(output)) {
-      installStatus = "configured";
-      availability = "needs_login";
-      loginProfile = "needs_login";
-      probeReason = "login_required";
-    } else if (LIMIT_PATTERNS.test(output)) {
-      installStatus = "configured";
-      availability = "recently_limited";
-      quotaSignal = "recently_limited";
-      probeReason = "quota_limited";
-    } else {
-      installStatus = "configured";
-      availability = "configured";
-      probeReason = "version_probe_failed";
-    }
-  } else if (signals.homeConfigPresent || signals.npmPackagePresent || signals.envConfigured) {
-    installStatus = "installed_not_on_path";
-    availability = "unavailable";
-    probeReason = "installed_not_on_path";
-  }
-
-  const models = activeModel ? [
-    inferModelRecord({
-      toolId: "gemini_cli",
-      providerId: "google",
-      modelId: activeModel,
-      availability: availability === "confirmed" ? "confirmed" : "candidate",
-      source: env.GEMINI_MODEL ? "env" : "inferred",
-      trustTier: "external",
-      privacyTier: "external_remote",
-      confidence: availability === "confirmed" ? "medium" : "low",
-    }),
-  ] : [];
-
-  return buildBaseToolRecord({
-    toolId: "gemini_cli",
-    label: "Gemini CLI",
-    providerId: "google",
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource: env.GEMINI_MODEL ? "env:GEMINI_MODEL" : null,
-    models,
-    supportedRoles: ["planning", "docs", "tests", "ui"],
-    costTier: "low",
-    qualityTier: "medium",
-    trustTier: "external",
-    privacyTier: "external_remote",
-    latencyTier: "fast",
-    quotaSignal,
-    executionMode: "handoff",
-    details: {
-      geminiApiKeyPresent: signals.envConfigured,
-      homeConfigPresent: signals.homeConfigPresent,
-      npmPackagePresent: signals.npmPackagePresent,
-      loginProfile,
-      probeReason,
-      pathCommandPresent: commandPresent,
-    },
-  });
-}
-
-module.exports = { discover };

package/scripts/lib/orchestration/provider-discovery/lm-studio.js

@@ -1,118 +0,0 @@
-"use strict";
-
-const path = require("path");
-const { inferModelRecord } = require("../model-profiler");
-const { buildBaseToolRecord, envPresence, safeHomeDir, pathExists, readLocalJson } = require("./common");
-
-const DEFAULT_BASE_URL = "http://127.0.0.1:1234";
-
-function signals(env, options = {}) {
-  const homeDir = safeHomeDir(options);
-  return {
-    appPathPresent: pathExists(path.join(homeDir, "AppData", "Local", "Programs", "LM Studio", "LM Studio.exe"))
-      || pathExists(path.join("C:\\", "Program Files", "LM Studio", "LM Studio.exe")),
-    appDataPresent: pathExists(path.join(homeDir, "AppData", "Roaming", "LM Studio")),
-    baseUrl: env.LM_STUDIO_BASE_URL || env.LMSTUDIO_BASE_URL || DEFAULT_BASE_URL,
-    modelHint: env.LM_STUDIO_MODEL || env.LMSTUDIO_MODEL || null,
-  };
-}
-
-function discover(cwd, context = {}) {
-  const env = context.env || process.env;
-  const s = signals(env, context);
-  const baseUrl = String(s.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
-  const localServerUrl = `${baseUrl}/v1/models`;
-  const nativeModelsUrl = `${baseUrl}/api/v1/models`;
-  const signalPresent = s.appPathPresent || s.appDataPresent || Boolean(s.modelHint) || envPresence(env, "LM_STUDIO_BASE_URL") || envPresence(env, "LMSTUDIO_BASE_URL");
-
-  let response = { ok: false, error: "server_unreachable" };
-  if (context.refreshLevel === "full" || context.refreshLevel === "deep" || context.refreshLevel === "single_model") {
-    response = readLocalJson(localServerUrl, {
-      cwd,
-      env,
-      timeoutMs: 1800,
-      httpGetJson: context.httpGetJson,
-    });
-    if ((!response.ok || !Array.isArray(response.body?.data)) && context.tryNativeLmStudio === true) {
-      response = readLocalJson(nativeModelsUrl, {
-        cwd,
-        env,
-        timeoutMs: 1800,
-        httpGetJson: context.httpGetJson,
-      });
-    }
-  }
-
-  const payload = Array.isArray(response?.body?.data)
-    ? response.body.data
-    : Array.isArray(response?.body?.models)
-      ? response.body.models
-      : [];
-  const models = payload
-    .map((entry) => entry && typeof entry.id === "string" ? entry.id.trim() : "")
-    .filter(Boolean)
-    .map((modelId) => inferModelRecord({
-      toolId: "lm_studio",
-      providerId: "local",
-      modelId,
-      displayName: modelId,
-      availability: "confirmed",
-      source: response.ok ? "local_server" : "inferred",
-      trustTier: "local",
-      privacyTier: "local_only",
-      confidence: "medium",
-      metadata: {},
-    }));
-
-  const activeModel = s.modelHint || models[0]?.modelId || null;
-  let installStatus = "not_installed";
-  let availability = "unavailable";
-  let note = "not_running";
-  if (response?.ok && models.length > 0) {
-    installStatus = "available";
-    availability = "confirmed";
-    note = "models_found";
-  } else if (response?.ok && models.length === 0) {
-    installStatus = "configured_but_no_models";
-    availability = "configured";
-    note = "server_empty_models";
-  } else if (signalPresent) {
-    installStatus = "installed_or_configured_but_not_running";
-    availability = "unavailable";
-    note = "server_unreachable";
-  }
-
-  const supportedRoles = models.some((model) => model.profiles.includes("coding_candidate"))
-    ? ["planning", "summaries", "docs", "local_private", "repo_reading", "cheap_build", "implementation"]
-    : ["planning", "summaries", "docs", "local_private", "repo_reading"];
-
-  return buildBaseToolRecord({
-    toolId: "lm_studio",
-    label: "LM Studio",
-    providerId: "lm_studio",
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource: s.modelHint ? (env.LM_STUDIO_MODEL ? "env:LM_STUDIO_MODEL" : "env:LMSTUDIO_MODEL") : null,
-    models,
-    supportedRoles,
-    costTier: "free_local",
-    qualityTier: models.some((model) => model.profiles.includes("coding_candidate")) ? "medium" : "unknown",
-    trustTier: "local",
-    privacyTier: "local_only",
-    latencyTier: "fast",
-    quotaSignal: "local",
-    executionMode: "handoff",
-    details: {
-      localServerUrl: baseUrl,
-      localServerReachable: Boolean(response?.ok),
-      appPathPresent: s.appPathPresent,
-      appDataPresent: s.appDataPresent,
-      modelCount: models.length,
-      probeReason: note,
-      nextAction: installStatus === "installed_or_configured_but_not_running" ? "Start LM Studio local server." : null,
-    },
-  });
-}
-
-module.exports = { discover };

package/scripts/lib/orchestration/provider-discovery/models-dev.js

@@ -1,12 +0,0 @@
-"use strict";
-
-function enrichModels(models, options = {}) {
-  const enabled = options.enableMetadataEnrichment === true;
-  return {
-    enabled,
-    source: enabled ? "models_dev_stub" : "disabled",
-    models: Array.isArray(models) ? models.slice() : [],
-  };
-}
-
-module.exports = { enrichModels };

package/scripts/lib/orchestration/provider-discovery/ollama.js

@@ -1,100 +0,0 @@
-"use strict";
-
-const { inferModelRecord } = require("../model-profiler");
-const { buildBaseToolRecord, envPresence, runCommand, readLocalJson } = require("./common");
-
-function parseTags(payload) {
-  return Array.isArray(payload?.models) ? payload.models : [];
-}
-
-function discover(cwd, context = {}) {
-  const env = context.env || process.env;
-  const exists = context.commandExists;
-  const commandPresent = exists("ollama", env);
-  const host = env.OLLAMA_HOST || "http://localhost:11434";
-  let entries = [];
-  let localReachable = false;
-
-  if (context.refreshLevel === "full" || context.refreshLevel === "deep" || context.refreshLevel === "single_model") {
-    const response = readLocalJson(`${String(host).replace(/\/+$/, "")}/api/tags`, {
-      cwd,
-      env,
-      timeoutMs: 1800,
-      httpGetJson: context.httpGetJson,
-    });
-    if (response.ok) {
-      entries = parseTags(response.body);
-      localReachable = true;
-    } else if (commandPresent) {
-      const result = runCommand("ollama", ["list"], {
-        cwd,
-        env,
-        timeoutMs: 1200,
-        commandRunner: context.commandRunner,
-      });
-      if (Number(result?.status) === 0) {
-        entries = String(result.stdout || "")
-          .split(/\r?\n/)
-          .slice(1)
-          .map((line) => line.trim().split(/\s+/)[0])
-          .filter(Boolean)
-          .map((name) => ({ name }));
-      }
-    }
-  }
-
-  const models = entries.map((entry) => {
-    const modelId = entry.model || entry.name;
-    return inferModelRecord({
-      toolId: "ollama",
-      providerId: "local",
-      modelId,
-      displayName: modelId,
-      availability: "confirmed",
-      source: localReachable ? "local_server" : "cli",
-      trustTier: "local",
-      privacyTier: "local_only",
-      confidence: "medium",
-      metadata: {
-        family: entry.details?.family,
-        families: entry.details?.families || [],
-        notes: [
-          entry.details?.parameter_size ? `parameter_size=${entry.details.parameter_size}` : null,
-          entry.details?.quantization_level ? `quantization=${entry.details.quantization_level}` : null,
-        ].filter(Boolean),
-      },
-    });
-  });
-
-  const activeModel = env.OLLAMA_MODEL || models[0]?.modelId || null;
-  const installStatus = commandPresent || envPresence(env, "OLLAMA_HOST") ? "configured" : "not_installed";
-  const availability = models.length > 0 ? "confirmed" : (installStatus === "configured" ? "configured" : "unavailable");
-  const supportedRoles = models.some((model) => model.profiles.includes("coding_candidate"))
-    ? ["planning", "summaries", "docs", "repo_reading", "cheap_build", "local_private", "implementation"]
-    : ["planning", "summaries", "docs", "repo_reading", "local_private"];
-
-  return buildBaseToolRecord({
-    toolId: "ollama",
-    label: "Ollama",
-    providerId: "ollama",
-    installStatus,
-    availability,
-    activeModel,
-    configuredModelSource: env.OLLAMA_MODEL ? "env:OLLAMA_MODEL" : null,
-    models,
-    supportedRoles,
-    costTier: "free_local",
-    qualityTier: models.some((model) => model.profiles.includes("coding_candidate")) ? "medium" : "unknown",
-    trustTier: "local",
-    privacyTier: "local_only",
-    latencyTier: "fast",
-    quotaSignal: "local",
-    details: {
-      ollamaHostPresent: envPresence(env, "OLLAMA_HOST"),
-      localServerReachable: localReachable,
-      modelCount: models.length,
-    },
-  });
-}
-
-module.exports = { discover };