@jmanuelcorral/openteam 0.1.3 → 0.1.4

package/dist/cli.js

@@ -2,9 +2,475 @@
 
 // src/cli.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile2 } from "node:fs/promises";
+import { access, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
 import { promisify } from "node:util";
 
+// src/cli/initAdapters.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  note,
+  outro,
+  select,
+  text
+} from "@clack/prompts";
+
+// src/local/openai-compatible.ts
+function normalizeBaseURL(baseURL) {
+  return baseURL.replace(/\/+$/, "");
+}
+function modelsEndpoint(baseURL) {
+  return `${normalizeBaseURL(baseURL)}/models`;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function listOpenAICompatibleModels(baseURL, fetch) {
+  const response = await fetch(modelsEndpoint(baseURL), {
+    method: "GET",
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`GET /models failed with HTTP ${response.status}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (error) {
+    throw new Error(`Malformed JSON from /models: ${errorMessage(error)}`);
+  }
+  return parseOpenAIModels(payload);
+}
+function parseOpenAIModels(payload) {
+  if (!isObject(payload) || !Array.isArray(payload.data)) {
+    throw new Error("Malformed /models response: expected data array");
+  }
+  return payload.data.map(parseOpenAIModel);
+}
+function unavailableSnapshot(input) {
+  return {
+    id: input.id,
+    baseURL: input.baseURL,
+    reachable: false,
+    models: [],
+    probedAt: input.probedAt,
+    error: errorMessage(input.error)
+  };
+}
+async function probeOpenAICompatibleRuntime(input) {
+  const normalizedBaseURL = normalizeBaseURL(input.baseURL);
+  try {
+    return {
+      id: input.id,
+      baseURL: normalizedBaseURL,
+      reachable: true,
+      models: await listOpenAICompatibleModels(normalizedBaseURL, input.fetch),
+      probedAt: input.probedAt
+    };
+  } catch (error) {
+    return unavailableSnapshot({
+      id: input.id,
+      baseURL: normalizedBaseURL,
+      probedAt: input.probedAt,
+      error
+    });
+  }
+}
+function parseOpenAIModel(value) {
+  if (!isObject(value) || typeof value.id !== "string" || value.id.length === 0) {
+    throw new Error("Malformed /models response: model id must be a string");
+  }
+  const contextWindow = readContextWindow(value);
+  const model = {
+    modelID: value.id,
+    supportsTools: readSupportsTools(value)
+  };
+  if (contextWindow !== undefined) {
+    model.contextWindow = contextWindow;
+  }
+  return model;
+}
+function readSupportsTools(model) {
+  const direct = readBoolean(model, [
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "supportsToolCalling",
+    "supports_tools",
+    "supportsTools"
+  ]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  const capabilities = readCapabilityBoolean(model.capabilities);
+  if (capabilities !== undefined) {
+    return capabilities;
+  }
+  const features = readCapabilityBoolean(model.features);
+  if (features !== undefined) {
+    return features;
+  }
+  return "unknown";
+}
+function readCapabilityBoolean(value) {
+  if (Array.isArray(value)) {
+    if (value.some((entry) => typeof entry === "string" && ["tools", "tool_call", "tool-calling", "function_calling"].includes(entry))) {
+      return true;
+    }
+    return;
+  }
+  if (!isObject(value)) {
+    return;
+  }
+  return readBoolean(value, [
+    "tools",
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "function_calling",
+    "supportsToolCalling"
+  ]);
+}
+function readContextWindow(model) {
+  const direct = readPositiveInteger(model, [
+    "contextWindow",
+    "context_window",
+    "context_length",
+    "max_context_length",
+    "n_ctx"
+  ]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  if (isObject(model.limit)) {
+    return readPositiveInteger(model.limit, ["context"]);
+  }
+  return;
+}
+function readBoolean(object, keys) {
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return;
+}
+function readPositiveInteger(object, keys) {
+  for (const key of keys) {
+    const value = object[key];
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/local/foundry-local.ts
+async function discoverFoundryLocalBaseURL(input) {
+  const result = await input.exec(input.command ?? "foundry", [
+    ...input.args ?? ["service", "status"]
+  ]);
+  if (result.exitCode !== 0) {
+    throw new Error(`Foundry Local discovery failed with exit code ${result.exitCode}: ${result.stderr || result.stdout}`);
+  }
+  const endpoint = parseFoundryEndpoint(`${result.stdout}
+${result.stderr}`);
+  if (endpoint === undefined) {
+    throw new Error("Foundry Local discovery did not return an endpoint");
+  }
+  return endpoint;
+}
+function createFoundryLocalAdapter() {
+  return {
+    id: "foundry-local",
+    listModels: async (options) => {
+      const baseURL = await resolveFoundryBaseURL(options);
+      return listOpenAICompatibleModels(baseURL, options.fetch);
+    },
+    probe: async (options) => {
+      let baseURL = options.baseURL ?? "";
+      try {
+        baseURL = await resolveFoundryBaseURL(options);
+      } catch (error) {
+        return unavailableSnapshot({
+          id: "foundry-local",
+          baseURL,
+          probedAt: options.probedAt,
+          error
+        });
+      }
+      return probeOpenAICompatibleRuntime({
+        id: "foundry-local",
+        baseURL,
+        fetch: options.fetch,
+        probedAt: options.probedAt
+      });
+    }
+  };
+}
+async function resolveFoundryBaseURL(options) {
+  if (options.baseURL !== undefined) {
+    return normalizeBaseURL(options.baseURL);
+  }
+  if (options.discovery === undefined) {
+    throw new Error("Foundry Local discovery is required when baseURL is absent");
+  }
+  return normalizeFoundryDiscovery(await options.discovery());
+}
+function normalizeFoundryDiscovery(discovery) {
+  if (typeof discovery === "string") {
+    return ensureFoundryV1BaseURL(discovery);
+  }
+  if ("baseURL" in discovery) {
+    return ensureFoundryV1BaseURL(discovery.baseURL);
+  }
+  const host = discovery.host ?? "localhost";
+  const protocol = discovery.protocol ?? "http";
+  return `${protocol}://${host}:${discovery.port}/v1`;
+}
+function foundryDiscoveryFromExec(exec) {
+  return () => discoverFoundryLocalBaseURL({ exec });
+}
+function parseFoundryEndpoint(output) {
+  const explicitURL = output.match(/https?:\/\/[^\s"'<>),]+/u)?.[0];
+  if (explicitURL !== undefined) {
+    return ensureFoundryV1BaseURL(explicitURL);
+  }
+  const localhostPort = output.match(/(?:localhost|127\.0\.0\.1|\[::1\])\s*:\s*(\d{2,5})/u);
+  const port = localhostPort?.[1];
+  if (port !== undefined) {
+    return `http://localhost:${port}/v1`;
+  }
+  return;
+}
+function ensureFoundryV1BaseURL(endpoint) {
+  const normalizedEndpoint = endpoint.trim().replace(/[),.;]+$/u, "");
+  const withProtocol = /^[a-z]+:\/\//iu.test(normalizedEndpoint) ? normalizedEndpoint : `http://${normalizedEndpoint}`;
+  try {
+    const url = new URL(withProtocol);
+    const path = normalizeBaseURL(url.pathname);
+    if (path.endsWith("/v1")) {
+      return normalizeBaseURL(url.toString());
+    }
+    return `${url.origin}/v1`;
+  } catch (error) {
+    throw new Error(`Invalid Foundry Local endpoint: ${errorMessage(error)}`);
+  }
+}
+
+// src/local/lmstudio.ts
+var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
+function createLMStudioAdapter() {
+  return {
+    id: "lmstudio",
+    defaultBaseURL: LMSTUDIO_DEFAULT_BASE_URL,
+    listModels(options) {
+      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? LMSTUDIO_DEFAULT_BASE_URL), options.fetch);
+    },
+    probe(options) {
+      return probeOpenAICompatibleRuntime({
+        id: "lmstudio",
+        baseURL: options.baseURL ?? LMSTUDIO_DEFAULT_BASE_URL,
+        fetch: options.fetch,
+        probedAt: options.probedAt
+      });
+    }
+  };
+}
+
+// src/local/ollama.ts
+var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
+function createOllamaAdapter() {
+  return {
+    id: "ollama",
+    defaultBaseURL: OLLAMA_DEFAULT_BASE_URL,
+    listModels(options) {
+      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? OLLAMA_DEFAULT_BASE_URL), options.fetch);
+    },
+    probe(options) {
+      return probeOpenAICompatibleRuntime({
+        id: "ollama",
+        baseURL: options.baseURL ?? OLLAMA_DEFAULT_BASE_URL,
+        fetch: options.fetch,
+        probedAt: options.probedAt
+      });
+    }
+  };
+}
+
+// src/local/registry.ts
+class RuntimeRegistry {
+  adapters;
+  clock;
+  fetch;
+  foundryDiscovery;
+  constructor(options) {
+    this.adapters = {
+      ollama: createOllamaAdapter(),
+      lmstudio: createLMStudioAdapter(),
+      "foundry-local": createFoundryLocalAdapter(),
+      ...options.adapters
+    };
+    this.clock = options.clock;
+    this.fetch = options.fetch;
+    this.foundryDiscovery = options.foundryDiscovery;
+  }
+  async probe(runtimes) {
+    const snapshots = [];
+    for (const runtime of runtimes) {
+      if (!runtime.enabled) {
+        continue;
+      }
+      const probedAt = this.clock();
+      const adapter = this.adapters[runtime.id];
+      const options = this.createProbeOptions(runtime, probedAt);
+      try {
+        snapshots.push(await adapter.probe(options));
+      } catch (error) {
+        snapshots.push(unavailableSnapshot({
+          id: runtime.id,
+          baseURL: runtime.baseURL ?? adapter.defaultBaseURL ?? "",
+          probedAt,
+          error: `Adapter threw unexpectedly: ${errorMessage(error)}`
+        }));
+      }
+    }
+    return snapshots;
+  }
+  createProbeOptions(runtime, probedAt) {
+    const options = {
+      fetch: this.fetch,
+      probedAt
+    };
+    if (runtime.baseURL !== undefined) {
+      options.baseURL = runtime.baseURL;
+    }
+    if (runtime.id === "foundry-local" && runtime.discovery !== "manual" && this.foundryDiscovery !== undefined) {
+      options.discovery = this.foundryDiscovery;
+    }
+    return options;
+  }
+}
+
+// src/cli/initAdapters.ts
+class PromptCancelledError extends Error {
+  constructor() {
+    super("prompt cancelado");
+    this.name = "PromptCancelledError";
+  }
+}
+function unwrap(value) {
+  if (isCancel(value)) {
+    cancel("Operación cancelada.");
+    throw new PromptCancelledError;
+  }
+  return value;
+}
+function toOption(choice) {
+  const option = { value: choice.value, label: choice.label };
+  if (choice.hint !== undefined) {
+    option.hint = choice.hint;
+  }
+  return option;
+}
+var clackPrompter = {
+  intro(title) {
+    intro(title);
+  },
+  outro(message) {
+    outro(message);
+  },
+  note(message, title) {
+    note(message, title);
+  },
+  async select(opts) {
+    const result = await select({
+      message: opts.message,
+      options: opts.choices.map(toOption),
+      ...opts.initial !== undefined ? { initialValue: opts.initial } : {}
+    });
+    return unwrap(result);
+  },
+  async multiselect(opts) {
+    const initialValues = opts.choices.filter((choice) => choice.selected === true).map((choice) => choice.value);
+    const result = await multiselect({
+      message: opts.message,
+      options: opts.choices.map(toOption),
+      initialValues,
+      required: opts.required ?? false
+    });
+    return unwrap(result);
+  },
+  async confirm(opts) {
+    const result = await confirm({
+      message: opts.message,
+      initialValue: opts.initial ?? false
+    });
+    return unwrap(result);
+  },
+  async text(opts) {
+    const result = await text({
+      message: opts.message,
+      ...opts.placeholder !== undefined ? { placeholder: opts.placeholder } : {},
+      ...opts.initial !== undefined ? { initialValue: opts.initial } : {}
+    });
+    return unwrap(result);
+  }
+};
+var DETECTION_RUNTIMES = [
+  {
+    id: "ollama",
+    enabled: true,
+    baseURL: "http://localhost:11434/v1",
+    defaultModel: { providerID: "ollama", modelID: "probe" }
+  },
+  {
+    id: "lmstudio",
+    enabled: true,
+    baseURL: "http://localhost:1234/v1",
+    defaultModel: { providerID: "lmstudio", modelID: "probe" }
+  },
+  {
+    id: "foundry-local",
+    enabled: true,
+    discovery: "cli",
+    defaultModel: { providerID: "foundry-local", modelID: "probe" }
+  }
+];
+function createDetect(exec) {
+  return async () => {
+    const registry = new RuntimeRegistry({
+      fetch: globalThis.fetch,
+      clock: () => new Date().toISOString(),
+      foundryDiscovery: foundryDiscoveryFromExec(exec)
+    });
+    const snapshots = await registry.probe(DETECTION_RUNTIMES);
+    return snapshots.map((snapshot) => {
+      const detected = {
+        id: snapshot.id,
+        baseURL: snapshot.baseURL,
+        reachable: snapshot.reachable,
+        models: snapshot.models.map((model) => model.modelID)
+      };
+      if (snapshot.error !== undefined) {
+        detected.error = snapshot.error;
+      }
+      return detected;
+    });
+  };
+}
+
 // src/config/schema.ts
 import { z } from "zod";
 var ModelRefSchema = z.object({
@@ -250,6 +716,7 @@ var HELP = [
   "openteam — comandos runtime",
   "",
   "Uso:",
+  "  openteam init                     Configura opencode + openteam (interactivo)",
   "  openteam baseline show            Muestra el baseline efectivo",
   "  openteam baseline set <p/model>   Fija el baseline (modo pinned)",
   "  openteam baseline auto            Baseline cheapest-capable (modo auto)",
@@ -356,382 +823,390 @@ async function runCli(argv, deps) {
       return { exitCode: 0, stdout: HELP };
     }
     return {
-      exitCode: 1,
-      stdout: `Comando desconocido: ${command}
-
-${HELP}`
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { exitCode: 1, stdout: `Error: ${message}` };
-  }
-}
-
-// src/config/load.ts
-function loadOpenTeamConfig(raw) {
-  return OpenTeamConfigSchema.parse(raw ?? {});
-}
-
-// src/config/persist.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-var DEFAULT_CONFIG_PATH = ".opencode/openteam.json";
-function serializeOpenTeamConfig(config) {
-  const validated = OpenTeamConfigSchema.parse(config);
-  return `${JSON.stringify(validated, null, 2)}
-`;
-}
-async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, deps = {}) {
-  const mkdirFn = deps.mkdir ?? mkdir;
-  const writeFileFn = deps.writeFile ?? writeFile;
-  await mkdirFn(dirname(path), { recursive: true });
-  await writeFileFn(path, serializeOpenTeamConfig(config), "utf8");
-}
-
-// src/local/openai-compatible.ts
-function normalizeBaseURL(baseURL) {
-  return baseURL.replace(/\/+$/, "");
-}
-function modelsEndpoint(baseURL) {
-  return `${normalizeBaseURL(baseURL)}/models`;
-}
-function errorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-async function listOpenAICompatibleModels(baseURL, fetch) {
-  const response = await fetch(modelsEndpoint(baseURL), {
-    method: "GET",
-    headers: { accept: "application/json" }
-  });
-  if (!response.ok) {
-    throw new Error(`GET /models failed with HTTP ${response.status}`);
-  }
-  let payload;
-  try {
-    payload = await response.json();
-  } catch (error) {
-    throw new Error(`Malformed JSON from /models: ${errorMessage(error)}`);
-  }
-  return parseOpenAIModels(payload);
-}
-function parseOpenAIModels(payload) {
-  if (!isObject(payload) || !Array.isArray(payload.data)) {
-    throw new Error("Malformed /models response: expected data array");
-  }
-  return payload.data.map(parseOpenAIModel);
-}
-function unavailableSnapshot(input) {
-  return {
-    id: input.id,
-    baseURL: input.baseURL,
-    reachable: false,
-    models: [],
-    probedAt: input.probedAt,
-    error: errorMessage(input.error)
-  };
-}
-async function probeOpenAICompatibleRuntime(input) {
-  const normalizedBaseURL = normalizeBaseURL(input.baseURL);
-  try {
-    return {
-      id: input.id,
-      baseURL: normalizedBaseURL,
-      reachable: true,
-      models: await listOpenAICompatibleModels(normalizedBaseURL, input.fetch),
-      probedAt: input.probedAt
-    };
-  } catch (error) {
-    return unavailableSnapshot({
-      id: input.id,
-      baseURL: normalizedBaseURL,
-      probedAt: input.probedAt,
-      error
-    });
-  }
-}
-function parseOpenAIModel(value) {
-  if (!isObject(value) || typeof value.id !== "string" || value.id.length === 0) {
-    throw new Error("Malformed /models response: model id must be a string");
-  }
-  const contextWindow = readContextWindow(value);
-  const model = {
-    modelID: value.id,
-    supportsTools: readSupportsTools(value)
-  };
-  if (contextWindow !== undefined) {
-    model.contextWindow = contextWindow;
-  }
-  return model;
-}
-function readSupportsTools(model) {
-  const direct = readBoolean(model, [
-    "tool_call",
-    "tool_calls",
-    "toolCalling",
-    "supportsToolCalling",
-    "supports_tools",
-    "supportsTools"
-  ]);
-  if (direct !== undefined) {
-    return direct;
-  }
-  const capabilities = readCapabilityBoolean(model.capabilities);
-  if (capabilities !== undefined) {
-    return capabilities;
-  }
-  const features = readCapabilityBoolean(model.features);
-  if (features !== undefined) {
-    return features;
-  }
-  return "unknown";
-}
-function readCapabilityBoolean(value) {
-  if (Array.isArray(value)) {
-    if (value.some((entry) => typeof entry === "string" && ["tools", "tool_call", "tool-calling", "function_calling"].includes(entry))) {
-      return true;
-    }
-    return;
-  }
-  if (!isObject(value)) {
-    return;
-  }
-  return readBoolean(value, [
-    "tools",
-    "tool_call",
-    "tool_calls",
-    "toolCalling",
-    "function_calling",
-    "supportsToolCalling"
-  ]);
-}
-function readContextWindow(model) {
-  const direct = readPositiveInteger(model, [
-    "contextWindow",
-    "context_window",
-    "context_length",
-    "max_context_length",
-    "n_ctx"
-  ]);
-  if (direct !== undefined) {
-    return direct;
-  }
-  if (isObject(model.limit)) {
-    return readPositiveInteger(model.limit, ["context"]);
-  }
-  return;
-}
-function readBoolean(object, keys) {
-  for (const key of keys) {
-    const value = object[key];
-    if (typeof value === "boolean") {
-      return value;
-    }
+      exitCode: 1,
+      stdout: `Comando desconocido: ${command}
+
+${HELP}`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 1, stdout: `Error: ${message}` };
   }
-  return;
 }
-function readPositiveInteger(object, keys) {
-  for (const key of keys) {
-    const value = object[key];
-    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
-      return value;
-    }
+
+// src/commands/init.ts
+import { join } from "node:path";
+
+// src/capabilities/curated.ts
+var CURATED_FRONTIER_PROFILES = [
+  {
+    ref: { providerID: "openai", modelID: "gpt-5.4-mini" },
+    kind: "frontier",
+    contextWindow: 128000,
+    maxOutputTokens: 16384,
+    supportsToolCalling: true,
+    supportsVision: true,
+    reasoningTier: 3,
+    codeQualityTier: 3,
+    costPer1M: { inputUSD: 0.8, outputUSD: 3.2 },
+    availability: "available"
+  },
+  {
+    ref: { providerID: "google", modelID: "gemini-3.5-flash" },
+    kind: "frontier",
+    contextWindow: 1e6,
+    maxOutputTokens: 65536,
+    supportsToolCalling: true,
+    supportsVision: true,
+    reasoningTier: 3,
+    codeQualityTier: 3,
+    costPer1M: { inputUSD: 0.35, outputUSD: 1.25 },
+    availability: "available"
+  },
+  {
+    ref: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
+    kind: "frontier",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    supportsToolCalling: true,
+    supportsVision: true,
+    reasoningTier: 4,
+    codeQualityTier: 5,
+    costPer1M: { inputUSD: 3, outputUSD: 15 },
+    availability: "available"
+  },
+  {
+    ref: { providerID: "openai", modelID: "gpt-5.3-codex" },
+    kind: "frontier",
+    contextWindow: 400000,
+    maxOutputTokens: 64000,
+    supportsToolCalling: true,
+    supportsVision: true,
+    reasoningTier: 5,
+    codeQualityTier: 5,
+    costPer1M: { inputUSD: 5, outputUSD: 20 },
+    availability: "available"
   }
-  return;
+];
+
+// src/config/persist.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+var DEFAULT_CONFIG_PATH = ".opencode/openteam.json";
+function serializeOpenTeamConfig(config) {
+  const validated = OpenTeamConfigSchema.parse(config);
+  return `${JSON.stringify(validated, null, 2)}
+`;
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, deps = {}) {
+  const mkdirFn = deps.mkdir ?? mkdir;
+  const writeFileFn = deps.writeFile ?? writeFile;
+  await mkdirFn(dirname(path), { recursive: true });
+  await writeFileFn(path, serializeOpenTeamConfig(config), "utf8");
 }
 
-// src/local/foundry-local.ts
-async function discoverFoundryLocalBaseURL(input) {
-  const result = await input.exec(input.command ?? "foundry", [
-    ...input.args ?? ["service", "status"]
-  ]);
-  if (result.exitCode !== 0) {
-    throw new Error(`Foundry Local discovery failed with exit code ${result.exitCode}: ${result.stderr || result.stdout}`);
+// src/commands/init.ts
+var OPENTEAM_PLUGIN_SPEC = "@jmanuelcorral/openteam";
+var OPENCODE_CONFIG_PATH = "opencode.json";
+var KNOWN_RUNTIMES = [
+  {
+    id: "ollama",
+    label: "Ollama",
+    defaultBaseURL: "http://localhost:11434/v1",
+    fallbackModelID: "qwen3:8b"
+  },
+  {
+    id: "lmstudio",
+    label: "LM Studio",
+    defaultBaseURL: "http://localhost:1234/v1",
+    fallbackModelID: "qwen2.5-coder"
+  },
+  {
+    id: "foundry-local",
+    label: "Foundry Local",
+    fallbackModelID: "Phi-4-mini-instruct",
+    dynamicPort: true
   }
-  const endpoint = parseFoundryEndpoint(`${result.stdout}
-${result.stderr}`);
-  if (endpoint === undefined) {
-    throw new Error("Foundry Local discovery did not return an endpoint");
+];
+function weightedCost(inputUSD, outputUSD) {
+  return 0.75 * inputUSD + 0.25 * outputUSD;
+}
+function frontierChoices() {
+  return [...CURATED_FRONTIER_PROFILES].sort((a, b) => weightedCost(a.costPer1M.inputUSD, a.costPer1M.outputUSD) - weightedCost(b.costPer1M.inputUSD, b.costPer1M.outputUSD)).map((profile) => ({
+    providerID: profile.ref.providerID,
+    modelID: profile.ref.modelID
+  }));
+}
+function knownRuntime(id) {
+  const found = KNOWN_RUNTIMES.find((runtime) => runtime.id === id);
+  if (found === undefined) {
+    throw new Error(`unknown runtime id: ${id}`);
   }
-  return endpoint;
+  return found;
 }
-function createFoundryLocalAdapter() {
-  return {
-    id: "foundry-local",
-    listModels: async (options) => {
-      const baseURL = await resolveFoundryBaseURL(options);
-      return listOpenAICompatibleModels(baseURL, options.fetch);
-    },
-    probe: async (options) => {
-      let baseURL = options.baseURL ?? "";
-      try {
-        baseURL = await resolveFoundryBaseURL(options);
-      } catch (error) {
-        return unavailableSnapshot({
-          id: "foundry-local",
-          baseURL,
-          probedAt: options.probedAt,
-          error
-        });
-      }
-      return probeOpenAICompatibleRuntime({
-        id: "foundry-local",
-        baseURL,
-        fetch: options.fetch,
-        probedAt: options.probedAt
-      });
+function firstEnabled(runtimes) {
+  return runtimes.find((runtime) => runtime.enabled);
+}
+function buildOpenTeamConfig(answers) {
+  const runtimes = answers.runtimes.map((choice) => {
+    const runtime = {
+      id: choice.id,
+      enabled: choice.enabled,
+      defaultModel: { providerID: choice.id, modelID: choice.defaultModelID }
+    };
+    if (choice.baseURL !== undefined) {
+      runtime.baseURL = choice.baseURL;
+    } else if (knownRuntime(choice.id).dynamicPort === true) {
+      runtime.discovery = "cli";
     }
+    return runtime;
+  });
+  const primaryLocal = firstEnabled(answers.runtimes);
+  const localDefault = primaryLocal !== undefined ? { providerID: primaryLocal.id, modelID: primaryLocal.defaultModelID } : {
+    providerID: runtimes[0]?.id ?? "ollama",
+    modelID: runtimes[0]?.defaultModel.modelID ?? "qwen3:8b"
   };
+  return OpenTeamConfigSchema.parse({
+    baseline: {
+      mode: "auto",
+      pinnedModel: null,
+      hardDefault: answers.frontier
+    },
+    router: {
+      mode: answers.routerMode,
+      localDefault
+    },
+    local: { runtimes },
+    privacyMode: answers.privacyMode
+  });
 }
-async function resolveFoundryBaseURL(options) {
-  if (options.baseURL !== undefined) {
-    return normalizeBaseURL(options.baseURL);
-  }
-  if (options.discovery === undefined) {
-    throw new Error("Foundry Local discovery is required when baseURL is absent");
+function buildOpencodeConfig(answers) {
+  const provider = {};
+  for (const choice of answers.runtimes) {
+    if (!choice.enabled) {
+      continue;
+    }
+    const meta = knownRuntime(choice.id);
+    const baseURL = choice.baseURL ?? meta.defaultBaseURL;
+    if (baseURL === undefined) {
+      continue;
+    }
+    const modelIDs = choice.models.length > 0 ? choice.models : [choice.defaultModelID];
+    const models = {};
+    for (const modelID of modelIDs) {
+      models[modelID] = { name: modelID };
+    }
+    provider[choice.id] = {
+      npm: "@ai-sdk/openai-compatible",
+      name: `${meta.label} (local)`,
+      options: { baseURL },
+      models
+    };
   }
-  return normalizeFoundryDiscovery(await options.discovery());
-}
-function normalizeFoundryDiscovery(discovery) {
-  if (typeof discovery === "string") {
-    return ensureFoundryV1BaseURL(discovery);
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    plugin: [OPENTEAM_PLUGIN_SPEC],
+    model: `${answers.frontier.providerID}/${answers.frontier.modelID}`
+  };
+  if (Object.keys(provider).length > 0) {
+    config.provider = provider;
   }
-  if ("baseURL" in discovery) {
-    return ensureFoundryV1BaseURL(discovery.baseURL);
+  const primaryLocal = firstEnabled(answers.runtimes);
+  if (primaryLocal !== undefined) {
+    config.small_model = `${primaryLocal.id}/${primaryLocal.defaultModelID}`;
   }
-  const host = discovery.host ?? "localhost";
-  const protocol = discovery.protocol ?? "http";
-  return `${protocol}://${host}:${discovery.port}/v1`;
-}
-function foundryDiscoveryFromExec(exec) {
-  return () => discoverFoundryLocalBaseURL({ exec });
+  return config;
 }
-function parseFoundryEndpoint(output) {
-  const explicitURL = output.match(/https?:\/\/[^\s"'<>),]+/u)?.[0];
-  if (explicitURL !== undefined) {
-    return ensureFoundryV1BaseURL(explicitURL);
-  }
-  const localhostPort = output.match(/(?:localhost|127\.0\.0\.1|\[::1\])\s*:\s*(\d{2,5})/u);
-  const port = localhostPort?.[1];
-  if (port !== undefined) {
-    return `http://localhost:${port}/v1`;
-  }
-  return;
+function serializeOpencodeConfig(config) {
+  return `${JSON.stringify(config, null, 2)}
+`;
 }
-function ensureFoundryV1BaseURL(endpoint) {
-  const normalizedEndpoint = endpoint.trim().replace(/[),.;]+$/u, "");
-  const withProtocol = /^[a-z]+:\/\//iu.test(normalizedEndpoint) ? normalizedEndpoint : `http://${normalizedEndpoint}`;
-  try {
-    const url = new URL(withProtocol);
-    const path = normalizeBaseURL(url.pathname);
-    if (path.endsWith("/v1")) {
-      return normalizeBaseURL(url.toString());
-    }
-    return `${url.origin}/v1`;
-  } catch (error) {
-    throw new Error(`Invalid Foundry Local endpoint: ${errorMessage(error)}`);
+var CUSTOM_FRONTIER = "__custom__";
+async function chooseFrontier(prompt) {
+  const options = frontierChoices();
+  const selected = await prompt.select({
+    message: "Modelo frontier baseline (cheapest-capable primero)",
+    choices: [
+      ...options.map((choice) => ({
+        value: `${choice.providerID}/${choice.modelID}`,
+        label: `${choice.providerID}/${choice.modelID}`
+      })),
+      { value: CUSTOM_FRONTIER, label: "Otro (introducir provider/model)" }
+    ],
+    initial: options[0] ? `${options[0].providerID}/${options[0].modelID}` : CUSTOM_FRONTIER
+  });
+  const ref = selected === CUSTOM_FRONTIER ? await prompt.text({
+    message: "Modelo frontier en formato provider/model",
+    placeholder: "anthropic/claude-sonnet-4-5"
+  }) : selected;
+  const slash = ref.indexOf("/");
+  if (slash <= 0 || slash === ref.length - 1) {
+    throw new Error(`modelo frontier inválido: "${ref}" (usa provider/model)`);
   }
-}
-
-// src/local/lmstudio.ts
-var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
-function createLMStudioAdapter() {
   return {
-    id: "lmstudio",
-    defaultBaseURL: LMSTUDIO_DEFAULT_BASE_URL,
-    listModels(options) {
-      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? LMSTUDIO_DEFAULT_BASE_URL), options.fetch);
-    },
-    probe(options) {
-      return probeOpenAICompatibleRuntime({
-        id: "lmstudio",
-        baseURL: options.baseURL ?? LMSTUDIO_DEFAULT_BASE_URL,
-        fetch: options.fetch,
-        probedAt: options.probedAt
-      });
-    }
+    providerID: ref.slice(0, slash),
+    modelID: ref.slice(slash + 1)
   };
 }
-
-// src/local/ollama.ts
-var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
-function createOllamaAdapter() {
-  return {
-    id: "ollama",
-    defaultBaseURL: OLLAMA_DEFAULT_BASE_URL,
-    listModels(options) {
-      return listOpenAICompatibleModels(normalizeBaseURL(options.baseURL ?? OLLAMA_DEFAULT_BASE_URL), options.fetch);
-    },
-    probe(options) {
-      return probeOpenAICompatibleRuntime({
-        id: "ollama",
-        baseURL: options.baseURL ?? OLLAMA_DEFAULT_BASE_URL,
-        fetch: options.fetch,
-        probedAt: options.probedAt
-      });
-    }
+async function chooseRuntimeModel(prompt, detected, meta) {
+  if (detected.models.length === 0) {
+    return prompt.text({
+      message: `Modelo por defecto para ${meta.label} (no se detectaron modelos)`,
+      placeholder: meta.fallbackModelID,
+      initial: meta.fallbackModelID
+    });
+  }
+  const first = detected.models[0];
+  const opts = {
+    message: `Modelo local por defecto para ${meta.label}`,
+    choices: detected.models.map((modelID) => ({
+      value: modelID,
+      label: modelID
+    }))
   };
-}
-
-// src/local/registry.ts
-class RuntimeRegistry {
-  adapters;
-  clock;
-  fetch;
-  foundryDiscovery;
-  constructor(options) {
-    this.adapters = {
-      ollama: createOllamaAdapter(),
-      lmstudio: createLMStudioAdapter(),
-      "foundry-local": createFoundryLocalAdapter(),
-      ...options.adapters
-    };
-    this.clock = options.clock;
-    this.fetch = options.fetch;
-    this.foundryDiscovery = options.foundryDiscovery;
+  if (first !== undefined) {
+    opts.initial = first;
   }
-  async probe(runtimes) {
-    const snapshots = [];
-    for (const runtime of runtimes) {
-      if (!runtime.enabled) {
+  return prompt.select(opts);
+}
+async function runInit(deps) {
+  const { prompt } = deps;
+  try {
+    prompt.intro("openteam init — configura opencode con routing local-first");
+    const detected = await deps.detect();
+    const detectedById = new Map(detected.map((item) => [item.id, item]));
+    const reachableIds = detected.filter((item) => item.reachable).map((item) => item.id);
+    const enabledIds = await prompt.multiselect({
+      message: "¿Qué runtimes locales quieres habilitar?",
+      choices: KNOWN_RUNTIMES.map((meta) => {
+        const info = detectedById.get(meta.id);
+        return {
+          value: meta.id,
+          label: meta.label,
+          hint: info?.reachable ? `detectado · ${info.models.length} modelo(s)` : "no detectado",
+          selected: info?.reachable ?? false
+        };
+      })
+    });
+    const enabled = new Set(enabledIds);
+    const runtimes = [];
+    for (const meta of KNOWN_RUNTIMES) {
+      const info = detectedById.get(meta.id);
+      const isEnabled = enabled.has(meta.id);
+      if (!isEnabled) {
+        const choice2 = {
+          id: meta.id,
+          enabled: false,
+          defaultModelID: meta.fallbackModelID,
+          models: info?.models ?? []
+        };
+        const disabledBaseURL = info?.baseURL ?? meta.defaultBaseURL;
+        if (disabledBaseURL !== undefined && disabledBaseURL.length > 0) {
+          choice2.baseURL = disabledBaseURL;
+        }
+        runtimes.push(choice2);
         continue;
       }
-      const probedAt = this.clock();
-      const adapter = this.adapters[runtime.id];
-      const options = this.createProbeOptions(runtime, probedAt);
-      try {
-        snapshots.push(await adapter.probe(options));
-      } catch (error) {
-        snapshots.push(unavailableSnapshot({
-          id: runtime.id,
-          baseURL: runtime.baseURL ?? adapter.defaultBaseURL ?? "",
-          probedAt,
-          error: `Adapter threw unexpectedly: ${errorMessage(error)}`
-        }));
+      const detectedRuntime = info ?? {
+        id: meta.id,
+        baseURL: meta.defaultBaseURL ?? "",
+        reachable: false,
+        models: []
+      };
+      const defaultModelID = await chooseRuntimeModel(prompt, detectedRuntime, meta);
+      const baseURL = info?.baseURL !== undefined && info.baseURL.length > 0 ? info.baseURL : meta.defaultBaseURL;
+      const choice = {
+        id: meta.id,
+        enabled: true,
+        defaultModelID,
+        models: detectedRuntime.models
+      };
+      if (baseURL !== undefined) {
+        choice.baseURL = baseURL;
       }
+      runtimes.push(choice);
     }
-    return snapshots;
-  }
-  createProbeOptions(runtime, probedAt) {
-    const options = {
-      fetch: this.fetch,
-      probedAt
+    const frontier = await chooseFrontier(prompt);
+    const routerMode = await prompt.select({
+      message: "Modo de routing",
+      choices: [
+        { value: "balanced", label: "balanced (recomendado)" },
+        { value: "economy", label: "economy (máximo ahorro, prioriza local)" },
+        { value: "quality", label: "quality (prioriza frontier)" }
+      ],
+      initial: "balanced"
+    });
+    const privacyMode = await prompt.select({
+      message: "Privacidad para prompts sensibles",
+      choices: [
+        {
+          value: "forceLocalOnSensitive",
+          label: "forceLocalOnSensitive (nunca envía datos sensibles a frontier)"
+        },
+        {
+          value: "consentBeforeFrontier",
+          label: "consentBeforeFrontier (pide consentimiento)"
+        },
+        { value: "off", label: "off (sin protección)" }
+      ],
+      initial: "forceLocalOnSensitive"
+    });
+    const answers = {
+      runtimes,
+      frontier,
+      routerMode,
+      privacyMode
     };
-    if (runtime.baseURL !== undefined) {
-      options.baseURL = runtime.baseURL;
+    const openTeamConfig = buildOpenTeamConfig(answers);
+    const opencodeConfig = buildOpencodeConfig(answers);
+    const openTeamPath = join(deps.cwd, DEFAULT_CONFIG_PATH);
+    const opencodePath = join(deps.cwd, OPENCODE_CONFIG_PATH);
+    const existing = [];
+    if (await deps.fileExists(openTeamPath)) {
+      existing.push(DEFAULT_CONFIG_PATH);
     }
-    if (runtime.id === "foundry-local" && runtime.discovery !== "manual" && this.foundryDiscovery !== undefined) {
-      options.discovery = this.foundryDiscovery;
+    if (await deps.fileExists(opencodePath)) {
+      existing.push(OPENCODE_CONFIG_PATH);
     }
-    return options;
+    if (existing.length > 0) {
+      const overwrite = await prompt.confirm({
+        message: `Ya existe ${existing.join(" y ")}. ¿Sobrescribir?`,
+        initial: false
+      });
+      if (!overwrite) {
+        prompt.outro("init cancelado: no se sobrescribió ninguna configuración.");
+        return { exitCode: 1, stdout: "init cancelado por el usuario" };
+      }
+    }
+    await deps.writeFile(openTeamPath, serializeOpenTeamConfig(openTeamConfig));
+    await deps.writeFile(opencodePath, serializeOpencodeConfig(opencodeConfig));
+    const enabledSummary = runtimes.filter((runtime) => runtime.enabled).map((runtime) => `${runtime.id} (${runtime.defaultModelID})`).join(", ");
+    prompt.note([
+      `Baseline frontier: ${frontier.providerID}/${frontier.modelID}`,
+      `Runtimes locales: ${enabledSummary || "ninguno habilitado"}`,
+      `Escrito: ${OPENCODE_CONFIG_PATH}, ${DEFAULT_CONFIG_PATH}`,
+      "",
+      "Siguientes pasos:",
+      `  1. Autentica el provider frontier: opencode auth login`,
+      reachableIds.length === 0 ? "  2. Arranca tu runtime local (Ollama/LM Studio/Foundry) antes de usarlo" : "  2. Abre opencode en este repo; openteam enruta local-first automáticamente"
+    ].join(`
+`), "openteam configurado");
+    prompt.outro("Listo. Abre opencode para empezar.");
+    return {
+      exitCode: 0,
+      stdout: `openteam init completado: ${OPENCODE_CONFIG_PATH}, ${DEFAULT_CONFIG_PATH}`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 1, stdout: `Error en init: ${message}` };
   }
 }
 
+// src/config/load.ts
+function loadOpenTeamConfig(raw) {
+  return OpenTeamConfigSchema.parse(raw ?? {});
+}
+
 // src/telemetry/read.ts
 import { readFile } from "node:fs/promises";
 
@@ -793,9 +1268,9 @@ var CostRecordSchema = z3.object({
 
 // src/telemetry/read.ts
 var DEFAULT_TELEMETRY_PATH = ".opencode/openteam-telemetry.jsonl";
-function parseCostRecordsJsonl(text) {
+function parseCostRecordsJsonl(text2) {
   const records = [];
-  for (const line of text.split(`
+  for (const line of text2.split(`
 `)) {
     const trimmed = line.trim();
     if (trimmed.length === 0) {
@@ -874,8 +1349,37 @@ var deps = {
   configPath: DEFAULT_CONFIG_PATH,
   telemetryPath: DEFAULT_TELEMETRY_PATH
 };
+function createInitDeps() {
+  return {
+    cwd: process.cwd(),
+    detect: createDetect(nodeExec),
+    prompt: clackPrompter,
+    writeFile: async (path, contents) => {
+      await mkdir2(dirname2(path), { recursive: true });
+      await writeFile2(path, contents, "utf8");
+    },
+    fileExists: async (path) => {
+      try {
+        await access(path);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
 async function main() {
-  const result = await runCli(process.argv.slice(2), deps);
+  const argv = process.argv.slice(2);
+  if (argv[0] === "init") {
+    const result2 = await runInit(createInitDeps());
+    if (result2.stdout.length > 0) {
+      process.stdout.write(`${result2.stdout}
+`);
+    }
+    process.exitCode = result2.exitCode;
+    return;
+  }
+  const result = await runCli(argv, deps);
   process.stdout.write(`${result.stdout}
 `);
   process.exitCode = result.exitCode;