avorelo 0.1.0

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

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

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

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

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

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

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

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

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