@corbat-tech/coco 2.33.2 → 2.35.0

package/dist/index.js

@@ -44,8 +44,13 @@ import yaml from 'highlight.js/lib/languages/yaml';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -253,6 +258,793 @@ var init_logger = __esm({
     globalLogger = null;
   }
 });
+
+// src/providers/catalog.ts
+function model(entry) {
+  return {
+    ...entry,
+    source: entry.source ?? SOURCES.providerDocs
+  };
+}
+function getProviderCatalogEntry(provider) {
+  return PROVIDER_CATALOG[provider];
+}
+function getCatalogDefaultModel(provider) {
+  return getProviderCatalogEntry(provider).defaultModel;
+}
+function getCatalogModel(provider, modelId) {
+  return getProviderCatalogEntry(provider).models.find((modelEntry) => modelEntry.id === modelId);
+}
+function getCatalogContextWindow(provider, modelId, fallback) {
+  if (!modelId) return fallback;
+  const exact = getCatalogModel(provider, modelId);
+  if (exact) return exact.contextWindow;
+  return fallback;
+}
+function getCatalogModelPricingMap() {
+  const pricing = {};
+  for (const provider of Object.values(PROVIDER_CATALOG)) {
+    for (const modelEntry of provider.models) {
+      if (!modelEntry.pricing) continue;
+      pricing[modelEntry.id] = {
+        ...modelEntry.pricing,
+        contextWindow: modelEntry.contextWindow
+      };
+    }
+  }
+  return pricing;
+}
+var VERIFIED_AT, SOURCES, PROVIDER_CATALOG;
+var init_catalog = __esm({
+  "src/providers/catalog.ts"() {
+    VERIFIED_AT = "2026-06-18";
+    SOURCES = {
+      openaiModels: {
+        name: "OpenAI models",
+        url: "https://developers.openai.com/api/docs/models",
+        verifiedAt: VERIFIED_AT
+      },
+      openaiAllModels: {
+        name: "OpenAI all models",
+        url: "https://developers.openai.com/api/docs/models/all",
+        verifiedAt: VERIFIED_AT
+      },
+      codexModels: {
+        name: "OpenAI Codex models",
+        url: "https://developers.openai.com/codex/models",
+        verifiedAt: VERIFIED_AT
+      },
+      anthropicModels: {
+        name: "Anthropic models overview",
+        url: "https://docs.anthropic.com/en/docs/about-claude/models/overview",
+        verifiedAt: VERIFIED_AT
+      },
+      anthropicDeprecations: {
+        name: "Anthropic model deprecations",
+        url: "https://docs.anthropic.com/en/docs/about-claude/model-deprecations",
+        verifiedAt: VERIFIED_AT
+      },
+      geminiModels: {
+        name: "Gemini API models",
+        url: "https://ai.google.dev/gemini-api/docs/models",
+        verifiedAt: VERIFIED_AT
+      },
+      geminiGuide: {
+        name: "Gemini 3 developer guide",
+        url: "https://ai.google.dev/gemini-api/docs/gemini-3",
+        verifiedAt: VERIFIED_AT
+      },
+      githubCopilotModels: {
+        name: "GitHub Copilot supported models",
+        url: "https://docs.github.com/copilot/reference/ai-models/supported-models",
+        verifiedAt: VERIFIED_AT
+      },
+      githubCopilotComparison: {
+        name: "GitHub Copilot model comparison",
+        url: "https://docs.github.com/en/copilot/reference/ai-models/model-comparison",
+        verifiedAt: VERIFIED_AT
+      },
+      moonshotDocs: {
+        name: "Moonshot AI docs",
+        url: "https://platform.moonshot.ai/docs",
+        verifiedAt: VERIFIED_AT
+      },
+      qwenDocs: {
+        name: "Alibaba Cloud Model Studio docs",
+        url: "https://www.alibabacloud.com/help/en/model-studio/",
+        verifiedAt: VERIFIED_AT
+      },
+      providerDocs: {
+        name: "Provider API documentation",
+        url: "https://github.com/corbat/corbat-coco/blob/main/docs/guides/PROVIDERS.md",
+        verifiedAt: VERIFIED_AT
+      }
+    };
+    PROVIDER_CATALOG = {
+      anthropic: {
+        id: "anthropic",
+        defaultModel: "claude-sonnet-4-6",
+        models: [
+          model({
+            id: "claude-opus-4-8",
+            name: "Claude Opus 4.8",
+            description: "Most capable Opus-tier model for complex agentic work",
+            contextWindow: 2e5,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "adaptive-thinking",
+              "reasoning-effort",
+              "anthropic-messages"
+            ],
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-sonnet-4-6",
+            name: "Claude Sonnet 4.6",
+            description: "Balanced default for coding, tool use, and long-running tasks",
+            contextWindow: 2e5,
+            maxOutputTokens: 128e3,
+            recommended: true,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "adaptive-thinking",
+              "reasoning-effort",
+              "anthropic-messages"
+            ],
+            pricing: { inputPerMillion: 3, outputPerMillion: 15 },
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-opus-4-6",
+            name: "Claude Opus 4.6",
+            description: "Legacy Opus option; prefer Opus 4.8 for new configurations",
+            contextWindow: 2e5,
+            maxOutputTokens: 128e3,
+            status: "legacy",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "adaptive-thinking",
+              "reasoning-effort",
+              "anthropic-messages"
+            ],
+            pricing: { inputPerMillion: 5, outputPerMillion: 25 },
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-haiku-4-5-20251001",
+            name: "Claude Haiku 4.5",
+            description: "Fast low-cost Claude model",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "anthropic-messages"],
+            pricing: { inputPerMillion: 1, outputPerMillion: 5 },
+            source: SOURCES.anthropicModels
+          }),
+          model({
+            id: "claude-sonnet-4-20250514",
+            name: "Claude Sonnet 4",
+            description: "Retired on the Claude API; kept for config migration warnings",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "vision", "thinking-budget", "anthropic-messages"],
+            pricing: { inputPerMillion: 3, outputPerMillion: 15 },
+            source: SOURCES.anthropicDeprecations
+          }),
+          model({
+            id: "claude-opus-4-20250514",
+            name: "Claude Opus 4",
+            description: "Retired on the Claude API; kept for config migration warnings",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "vision", "thinking-budget", "anthropic-messages"],
+            pricing: { inputPerMillion: 15, outputPerMillion: 75 },
+            source: SOURCES.anthropicDeprecations
+          })
+        ]
+      },
+      openai: {
+        id: "openai",
+        defaultModel: "gpt-5.5",
+        models: [
+          model({
+            id: "gpt-5.5",
+            name: "GPT-5.5",
+            description: "Default for complex coding, agentic workflows, and tool-heavy tasks",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "reasoning-effort", "openai-responses"],
+            pricing: { inputPerMillion: 5, outputPerMillion: 30 },
+            source: SOURCES.openaiModels
+          }),
+          model({
+            id: "gpt-5.4",
+            name: "GPT-5.4",
+            description: "Affordable model for coding and professional work",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-5.4-mini",
+            name: "GPT-5.4 mini",
+            description: "Fast model for lighter coding tasks and subagents",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-5.3-codex",
+            name: "GPT-5.3 Codex",
+            description: "Agentic coding model; keep separate from older ChatGPT-only aliases",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-5.2-codex",
+            name: "GPT-5.2 Codex",
+            description: "Deprecated Codex model retained for existing configs",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          }),
+          model({
+            id: "gpt-4.1",
+            name: "GPT-4.1",
+            description: "Legacy long-context non-reasoning model",
+            contextWindow: 1048576,
+            maxOutputTokens: 32768,
+            status: "legacy",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            pricing: { inputPerMillion: 2, outputPerMillion: 8 },
+            source: SOURCES.openaiAllModels
+          })
+        ]
+      },
+      codex: {
+        id: "codex",
+        defaultModel: "gpt-5.5",
+        models: [
+          model({
+            id: "gpt-5.5",
+            name: "GPT-5.5",
+            description: "Recommended Codex model for complex coding work",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.codexModels
+          }),
+          model({
+            id: "gpt-5.4-mini",
+            name: "GPT-5.4 mini",
+            description: "Faster Codex option for lighter work and subagents",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.codexModels
+          }),
+          model({
+            id: "gpt-5.3-codex-spark",
+            name: "GPT-5.3 Codex Spark",
+            description: "Research preview for near-instant coding iteration",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "experimental",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.codexModels
+          }),
+          model({
+            id: "codex-mini-latest",
+            name: "Codex mini latest",
+            description: "Deprecated fast Codex CLI model retained for existing configs",
+            contextWindow: 128e3,
+            maxOutputTokens: 32e3,
+            status: "deprecated",
+            capabilities: ["streaming", "tool-use", "reasoning-effort", "openai-responses"],
+            source: SOURCES.openaiAllModels
+          })
+        ]
+      },
+      copilot: {
+        id: "copilot",
+        defaultModel: "claude-sonnet-4.6",
+        models: [
+          model({
+            id: "claude-sonnet-4.6",
+            name: "Claude Sonnet 4.6",
+            description: "Reliable Copilot default for coding and review",
+            contextWindow: 168e3,
+            maxOutputTokens: 64e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotComparison
+          }),
+          model({
+            id: "gpt-5.5",
+            name: "GPT-5.5",
+            description: "Copilot model for complex reasoning and technical decisions",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotComparison
+          }),
+          model({
+            id: "gpt-5.4",
+            name: "GPT-5.4",
+            description: "Copilot coding model",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gpt-5.4-mini",
+            name: "GPT-5.4 mini",
+            description: "Fast Copilot model for interactive coding",
+            contextWindow: 1e6,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gpt-5.3-codex",
+            name: "GPT-5.3 Codex",
+            description: "Copilot agentic coding model",
+            contextWindow: 4e5,
+            maxOutputTokens: 128e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "claude-opus-4.8",
+            name: "Claude Opus 4.8",
+            description: "Most capable Anthropic model exposed by Copilot when available",
+            contextWindow: 168e3,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gemini-3.1-pro",
+            name: "Gemini 3.1 Pro",
+            description: "Gemini model exposed by Copilot",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          }),
+          model({
+            id: "gemini-3.5-flash",
+            name: "Gemini 3.5 Flash",
+            description: "Fast Gemini model exposed by Copilot",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"],
+            source: SOURCES.githubCopilotModels
+          })
+        ]
+      },
+      gemini: {
+        id: "gemini",
+        defaultModel: "gemini-3.1-pro-preview",
+        models: [
+          model({
+            id: "gemini-3.1-pro-preview",
+            name: "Gemini 3.1 Pro Preview",
+            description: "Most capable Gemini 3 model for agentic and coding workflows",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            recommended: true,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-3-flash-preview",
+            name: "Gemini 3 Flash Preview",
+            description: "Fast Gemini 3 preview model",
+            contextWindow: 1e6,
+            maxOutputTokens: 64e3,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-2.5-pro",
+            name: "Gemini 2.5 Pro",
+            description: "Stable Gemini Pro model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          }),
+          model({
+            id: "gemini-2.5-flash",
+            name: "Gemini 2.5 Flash",
+            description: "Stable fast Gemini model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          }),
+          model({
+            id: "gemini-2.5-flash-lite",
+            name: "Gemini 2.5 Flash-Lite",
+            description: "Lowest-cost stable Gemini option",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          })
+        ]
+      },
+      vertex: {
+        id: "vertex",
+        defaultModel: "gemini-2.5-pro",
+        models: [
+          model({
+            id: "gemini-2.5-pro",
+            name: "Gemini 2.5 Pro",
+            description: "Stable Vertex model for coding and complex reasoning",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            recommended: true,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          }),
+          model({
+            id: "gemini-3-pro-preview",
+            name: "Gemini 3 Pro Preview",
+            description: "Preview Vertex Gemini 3 model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-3-flash-preview",
+            name: "Gemini 3 Flash Preview",
+            description: "Fast preview Vertex Gemini 3 model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "experimental",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiGuide
+          }),
+          model({
+            id: "gemini-2.5-flash",
+            name: "Gemini 2.5 Flash",
+            description: "Fast stable Vertex Gemini model",
+            contextWindow: 1048576,
+            maxOutputTokens: 65536,
+            status: "current",
+            capabilities: [
+              "streaming",
+              "tool-use",
+              "vision",
+              "thinking-budget",
+              "gemini-generate-content"
+            ],
+            source: SOURCES.geminiModels
+          })
+        ]
+      },
+      kimi: {
+        id: "kimi",
+        defaultModel: "kimi-k2.5",
+        models: [
+          model({
+            id: "kimi-k2.5",
+            name: "Kimi K2.5",
+            description: "Moonshot model for coding and agentic work",
+            contextWindow: 262144,
+            maxOutputTokens: 32e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.moonshotDocs
+          }),
+          model({
+            id: "kimi-k2-thinking",
+            name: "Kimi K2 Thinking",
+            description: "Reasoning variant",
+            contextWindow: 262144,
+            maxOutputTokens: 32e3,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.moonshotDocs
+          }),
+          model({
+            id: "moonshot-v1-128k",
+            name: "Moonshot v1 128K",
+            description: "Legacy long-context Moonshot model",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            status: "legacy",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            pricing: { inputPerMillion: 6, outputPerMillion: 6 },
+            source: SOURCES.moonshotDocs
+          })
+        ]
+      },
+      "kimi-code": {
+        id: "kimi-code",
+        defaultModel: "kimi-for-coding",
+        models: [
+          model({
+            id: "kimi-for-coding",
+            name: "Kimi for Coding",
+            description: "Anthropic-compatible Kimi coding endpoint",
+            contextWindow: 131072,
+            maxOutputTokens: 32e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "anthropic-messages"],
+            source: SOURCES.moonshotDocs
+          })
+        ]
+      },
+      lmstudio: {
+        id: "lmstudio",
+        defaultModel: "local-model",
+        models: [
+          model({
+            id: "local-model",
+            name: "Local model",
+            description: "Model selected in LM Studio",
+            contextWindow: 32768,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      ollama: {
+        id: "ollama",
+        defaultModel: "llama3.2",
+        models: [
+          model({
+            id: "llama3.2",
+            name: "Llama 3.2",
+            description: "Default local Ollama model",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          }),
+          model({
+            id: "qwen2.5-coder:14b",
+            name: "Qwen2.5 Coder 14B",
+            description: "Local coding model",
+            contextWindow: 32768,
+            maxOutputTokens: 8192,
+            status: "legacy",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      groq: {
+        id: "groq",
+        defaultModel: "llama-3.3-70b-versatile",
+        models: [
+          model({
+            id: "llama-3.3-70b-versatile",
+            name: "Llama 3.3 70B Versatile",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      openrouter: {
+        id: "openrouter",
+        defaultModel: "anthropic/claude-sonnet-4.6",
+        models: [
+          model({
+            id: "anthropic/claude-sonnet-4.6",
+            name: "Claude Sonnet 4.6 via OpenRouter",
+            contextWindow: 2e5,
+            maxOutputTokens: 64e3,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "vision", "openai-chat"]
+          })
+        ]
+      },
+      mistral: {
+        id: "mistral",
+        defaultModel: "mistral-large-latest",
+        models: [
+          model({
+            id: "mistral-large-latest",
+            name: "Mistral Large latest",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          }),
+          model({
+            id: "codestral-latest",
+            name: "Codestral latest",
+            contextWindow: 32768,
+            maxOutputTokens: 8192,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      deepseek: {
+        id: "deepseek",
+        defaultModel: "deepseek-chat",
+        models: [
+          model({
+            id: "deepseek-chat",
+            name: "DeepSeek Chat",
+            contextWindow: 65536,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          }),
+          model({
+            id: "deepseek-reasoner",
+            name: "DeepSeek Reasoner",
+            contextWindow: 65536,
+            maxOutputTokens: 8192,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      together: {
+        id: "together",
+        defaultModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        models: [
+          model({
+            id: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+            name: "Llama 3.3 70B Instruct Turbo",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"]
+          })
+        ]
+      },
+      huggingface: {
+        id: "huggingface",
+        defaultModel: "meta-llama/Llama-3.1-70B-Instruct",
+        models: [
+          model({
+            id: "meta-llama/Llama-3.1-70B-Instruct",
+            name: "Llama 3.1 70B Instruct",
+            contextWindow: 128e3,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "legacy",
+            capabilities: ["streaming", "openai-chat"]
+          })
+        ]
+      },
+      qwen: {
+        id: "qwen",
+        defaultModel: "qwen-coder-plus",
+        models: [
+          model({
+            id: "qwen-coder-plus",
+            name: "Qwen Coder Plus",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            recommended: true,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.qwenDocs
+          }),
+          model({
+            id: "qwen-max",
+            name: "Qwen Max",
+            contextWindow: 131072,
+            maxOutputTokens: 8192,
+            status: "current",
+            capabilities: ["streaming", "tool-use", "openai-chat"],
+            source: SOURCES.qwenDocs
+          })
+        ]
+      }
+    };
+  }
+});
 async function refreshAccessToken(provider, refreshToken) {
   const config = OAUTH_CONFIGS[provider];
   if (!config) {
@@ -858,6 +1650,22 @@ function isCopilotTokenExpired(creds) {
   if (!creds.copilotToken || !creds.copilotTokenExpiresAt) return true;
   return Date.now() >= creds.copilotTokenExpiresAt - REFRESH_BUFFER_MS;
 }
+function exchangeForCopilotTokenViaGhCli() {
+  return new Promise((resolve3) => {
+    execFile("gh", ["api", "/copilot_internal/v2/token"], { timeout: 1e4 }, (err, stdout) => {
+      if (err || !stdout) {
+        resolve3(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        resolve3(parsed.token && parsed.expires_at ? parsed : null);
+      } catch {
+        resolve3(null);
+      }
+    });
+  });
+}
 async function getValidCopilotToken() {
   const creds = await loadCopilotCredentials();
   const envToken = process.env["COPILOT_GITHUB_TOKEN"] || process.env["GH_TOKEN"] || process.env["GITHUB_TOKEN"];
@@ -871,8 +1679,7 @@ async function getValidCopilotToken() {
       isNew: false
     };
   }
-  try {
-    const copilotToken = await exchangeForCopilotToken(githubToken);
+  const saveAndReturn = async (copilotToken) => {
     const updatedCreds = {
       ...creds ?? { githubToken },
       githubToken: creds?.githubToken ?? githubToken,
@@ -886,11 +1693,23 @@ async function getValidCopilotToken() {
       baseUrl: getCopilotBaseUrl(updatedCreds.accountType),
       isNew: true
     };
+  };
+  try {
+    const copilotToken = await exchangeForCopilotToken(githubToken);
+    return saveAndReturn(copilotToken);
   } catch (error) {
     if (error instanceof CopilotAuthError && error.permanent) {
+      const ghCliToken2 = await exchangeForCopilotTokenViaGhCli();
+      if (ghCliToken2) {
+        return saveAndReturn(ghCliToken2);
+      }
       await deleteCopilotCredentials();
       return null;
     }
+    const ghCliToken = await exchangeForCopilotTokenViaGhCli();
+    if (ghCliToken) {
+      return saveAndReturn(ghCliToken);
+    }
     throw error;
   }
 }
@@ -912,6 +1731,7 @@ var init_copilot = __esm({
         this.permanent = permanent;
         this.name = "CopilotAuthError";
       }
+      permanent;
     };
     CopilotCredentialsSchema = z.object({
       githubToken: z.string().min(1),
@@ -1487,8 +2307,8 @@ async function configExists(configPath, scope = "any") {
   }
   return false;
 }
-function getConfigValue(config, path42) {
-  const keys = path42.split(".");
+function getConfigValue(config, path44) {
+  const keys = path44.split(".");
   let current = config;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -1636,41 +2456,41 @@ function getBaseUrl(provider) {
 function getDefaultModel(provider) {
   switch (provider) {
     case "anthropic":
-      return process.env["ANTHROPIC_MODEL"] ?? "claude-opus-4-6";
+      return process.env["ANTHROPIC_MODEL"] ?? getCatalogDefaultModel(provider);
     case "openai":
-      return process.env["OPENAI_MODEL"] ?? "gpt-5.3-codex";
+      return process.env["OPENAI_MODEL"] ?? getCatalogDefaultModel(provider);
     case "gemini":
-      return process.env["GEMINI_MODEL"] ?? "gemini-3.1-pro-preview";
+      return process.env["GEMINI_MODEL"] ?? getCatalogDefaultModel(provider);
     case "vertex":
-      return process.env["VERTEX_MODEL"] ?? "gemini-2.5-pro";
+      return process.env["VERTEX_MODEL"] ?? getCatalogDefaultModel(provider);
     case "kimi":
-      return process.env["KIMI_MODEL"] ?? "kimi-k2.5";
+      return process.env["KIMI_MODEL"] ?? getCatalogDefaultModel(provider);
     case "kimi-code":
-      return process.env["KIMI_CODE_MODEL"] ?? "kimi-for-coding";
+      return process.env["KIMI_CODE_MODEL"] ?? getCatalogDefaultModel(provider);
     case "lmstudio":
-      return process.env["LMSTUDIO_MODEL"] ?? "local-model";
+      return process.env["LMSTUDIO_MODEL"] ?? getCatalogDefaultModel(provider);
     case "ollama":
-      return process.env["OLLAMA_MODEL"] ?? "llama3.2";
+      return process.env["OLLAMA_MODEL"] ?? getCatalogDefaultModel(provider);
     case "codex":
-      return process.env["CODEX_MODEL"] ?? "codex-mini-latest";
+      return process.env["CODEX_MODEL"] ?? getCatalogDefaultModel(provider);
     case "copilot":
-      return process.env["COPILOT_MODEL"] ?? "claude-sonnet-4.6";
+      return process.env["COPILOT_MODEL"] ?? getCatalogDefaultModel(provider);
     case "groq":
-      return process.env["GROQ_MODEL"] ?? "llama-3.3-70b-versatile";
+      return process.env["GROQ_MODEL"] ?? getCatalogDefaultModel(provider);
     case "openrouter":
-      return process.env["OPENROUTER_MODEL"] ?? "anthropic/claude-3.5-sonnet";
+      return process.env["OPENROUTER_MODEL"] ?? getCatalogDefaultModel(provider);
     case "mistral":
-      return process.env["MISTRAL_MODEL"] ?? "mistral-large-latest";
+      return process.env["MISTRAL_MODEL"] ?? getCatalogDefaultModel(provider);
     case "deepseek":
-      return process.env["DEEPSEEK_MODEL"] ?? "deepseek-chat";
+      return process.env["DEEPSEEK_MODEL"] ?? getCatalogDefaultModel(provider);
     case "together":
-      return process.env["TOGETHER_MODEL"] ?? "meta-llama/Llama-3.3-70B-Instruct-Turbo";
+      return process.env["TOGETHER_MODEL"] ?? getCatalogDefaultModel(provider);
     case "huggingface":
-      return process.env["HF_MODEL"] ?? "meta-llama/Llama-3.1-70B-Instruct";
+      return process.env["HF_MODEL"] ?? getCatalogDefaultModel(provider);
     case "qwen":
-      return process.env["QWEN_MODEL"] ?? "qwen-max";
+      return process.env["QWEN_MODEL"] ?? getCatalogDefaultModel(provider);
     default:
-      return "claude-sonnet-4-6";
+      return getCatalogDefaultModel("anthropic");
   }
 }
 function getDefaultProvider() {
@@ -1680,11 +2500,24 @@ function getDefaultProvider() {
   }
   return "anthropic";
 }
+function getEditorModel() {
+  const raw = process.env["COCO_EDITOR_MODEL"]?.trim();
+  if (!raw || raw.length === 0) return void 0;
+  if (["none", "default", "null", "undefined"].includes(raw.toLowerCase())) return void 0;
+  return raw;
+}
+function getWeakModel() {
+  const raw = process.env["COCO_WEAK_MODEL"]?.trim();
+  if (!raw || raw.length === 0) return void 0;
+  if (["none", "default", "null", "undefined"].includes(raw.toLowerCase())) return void 0;
+  return raw;
+}
 var VALID_PROVIDERS;
 var init_env = __esm({
   "src/config/env.ts"() {
     init_loader();
     init_paths();
+    init_catalog();
     loadGlobalCocoEnv();
     VALID_PROVIDERS = [
       "anthropic",
@@ -1709,7 +2542,9 @@ var init_env = __esm({
       provider: getDefaultProvider(),
       getApiKey,
       getBaseUrl,
-      getDefaultModel
+      getDefaultModel,
+      getWeakModel,
+      getEditorModel
     });
   }
 });
@@ -2019,9 +2854,9 @@ async function migrateGlobalConfig(oldDir, newConfigPath) {
     );
   }
 }
-async function fileExists3(path42) {
+async function fileExists3(path44) {
   try {
-    await access(path42);
+    await access(path44);
     return true;
   } catch {
     return false;
@@ -3054,10 +3889,10 @@ function inferTargetUsers(session) {
     /(?:for|by)\s+(developers?|users?|administrators?|customers?)/gi,
     /(developers?|users?|administrators?|customers?)\s+(?:can|will|should)/gi
   ];
-  const text = session.requirements.map((r) => r.description).join(" ");
+  const text2 = session.requirements.map((r) => r.description).join(" ");
   for (const pattern of userPatterns) {
     let match;
-    while ((match = pattern.exec(text)) !== null) {
+    while ((match = pattern.exec(text2)) !== null) {
       const user = match[1]?.toLowerCase();
       if (user && !users.includes(user)) {
         users.push(user);
@@ -3070,13 +3905,13 @@ function inferTargetUsers(session) {
   return users;
 }
 function inferProjectType(session) {
-  const text = session.initialInput.toLowerCase();
-  if (text.includes("cli") || text.includes("command line")) return "cli";
-  if (text.includes("api") || text.includes("rest") || text.includes("graphql")) return "api";
-  if (text.includes("web app") || text.includes("frontend")) return "web_app";
-  if (text.includes("library") || text.includes("package")) return "library";
-  if (text.includes("service") || text.includes("daemon")) return "service";
-  if (text.includes("full stack") || text.includes("fullstack")) return "full_stack";
+  const text2 = session.initialInput.toLowerCase();
+  if (text2.includes("cli") || text2.includes("command line")) return "cli";
+  if (text2.includes("api") || text2.includes("rest") || text2.includes("graphql")) return "api";
+  if (text2.includes("web app") || text2.includes("frontend")) return "web_app";
+  if (text2.includes("library") || text2.includes("package")) return "library";
+  if (text2.includes("service") || text2.includes("daemon")) return "service";
+  if (text2.includes("full stack") || text2.includes("fullstack")) return "full_stack";
   return "unknown";
 }
 function assessComplexity(session) {
@@ -4622,14 +5457,14 @@ function generateArchitectureMarkdown(doc) {
   if (doc.dataModels.length > 0) {
     sections.push("## Data Models");
     sections.push("");
-    for (const model of doc.dataModels) {
-      sections.push(`### ${model.name}`);
+    for (const model2 of doc.dataModels) {
+      sections.push(`### ${model2.name}`);
       sections.push("");
-      sections.push(model.description);
+      sections.push(model2.description);
       sections.push("");
       sections.push("| Field | Type | Required |");
       sections.push("|-------|------|----------|");
-      for (const field of model.fields) {
+      for (const field of model2.fields) {
         sections.push(`| ${field.name} | ${field.type} | ${field.required ? "Yes" : "No"} |`);
       }
       sections.push("");
@@ -5853,6 +6688,7 @@ var CoverageAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze coverage by running tests with coverage enabled
    */
@@ -6195,6 +7031,7 @@ var SnykSecurityScanner = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Scan project with Snyk (requires authentication)
    */
@@ -6406,6 +7243,8 @@ var ComplexityAnalyzer = class {
     this.projectPath = projectPath;
     this.threshold = threshold;
   }
+  projectPath;
+  threshold;
   /**
    * Analyze complexity of project files
    */
@@ -6491,6 +7330,8 @@ var DuplicationAnalyzer = class {
     this.projectPath = projectPath;
     this.minLines = minLines;
   }
+  projectPath;
+  minLines;
   /**
    * Detect code duplication
    */
@@ -6859,6 +7700,7 @@ var CorrectnessAnalyzer = class {
     this.projectPath = projectPath;
     this.buildVerifier = new BuildVerifier(projectPath);
   }
+  projectPath;
   buildVerifier;
   /**
    * Analyze correctness by running tests and verifying build
@@ -6991,6 +7833,7 @@ var CompletenessAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze project completeness
    */
@@ -7224,6 +8067,7 @@ var RobustnessAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze robustness of project files
    */
@@ -7381,6 +8225,7 @@ var TestQualityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze test quality across the project
    */
@@ -7510,6 +8355,7 @@ var DocumentationAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze documentation quality
    */
@@ -7664,6 +8510,7 @@ var StyleAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze style/linting quality
    */
@@ -7873,6 +8720,7 @@ var ReadabilityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze readability of project files
    */
@@ -8010,6 +8858,7 @@ var MaintainabilityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   /**
    * Analyze maintainability of project files
    */
@@ -8377,6 +9226,7 @@ var JavaComplexityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath);
     if (!javaFiles.length) {
@@ -8516,6 +9366,7 @@ var JavaSecurityAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath, { includeTests: false });
     if (!javaFiles.length) {
@@ -8580,6 +9431,7 @@ var JavaStyleAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath);
     if (!javaFiles.length) return { score: 100, violations: [] };
@@ -8678,6 +9530,7 @@ var JavaDocumentationAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const javaFiles = files ?? await findJavaFiles(this.projectPath, { srcPattern: "src/main/**/*.java" });
     if (!javaFiles.length) {
@@ -8755,6 +9608,7 @@ var JavaCoverageAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze() {
     for (const reportPath of JACOCO_REPORT_PATHS) {
       try {
@@ -8886,6 +9740,7 @@ var ReactComponentAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const reactFiles = files ?? await findReactFiles(this.projectPath);
     if (!reactFiles.length) return { score: 100, totalComponents: 0, issues: [] };
@@ -8985,6 +9840,7 @@ var ReactA11yAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const reactFiles = files ?? await findReactFiles(this.projectPath);
     if (!reactFiles.length) return { score: 100, violations: [] };
@@ -9077,6 +9933,7 @@ var ReactHookAnalyzer = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
+  projectPath;
   async analyze(files) {
     const reactFiles = files ?? await findReactFiles(this.projectPath, "**/*.{tsx,jsx,ts,js}");
     if (!reactFiles.length) return { score: 100, violations: [] };
@@ -9490,6 +10347,8 @@ var QualityEvaluator = class {
     this.readabilityAnalyzer = new ReadabilityAnalyzer(projectPath);
     this.maintainabilityAnalyzer = new MaintainabilityAnalyzer(projectPath);
   }
+  projectPath;
+  registry;
   coverageAnalyzer;
   securityScanner;
   complexityAnalyzer;
@@ -10107,12 +10966,12 @@ function humanizeError(message, toolName) {
     return msg;
   }
   if (/ENOENT/i.test(msg)) {
-    const path42 = extractQuotedPath(msg);
-    return path42 ? `File or directory not found: ${path42}` : "File or directory not found";
+    const path44 = extractQuotedPath(msg);
+    return path44 ? `File or directory not found: ${path44}` : "File or directory not found";
   }
   if (/EACCES/i.test(msg)) {
-    const path42 = extractQuotedPath(msg);
-    return path42 ? `Permission denied: ${path42}` : "Permission denied \u2014 check file permissions";
+    const path44 = extractQuotedPath(msg);
+    return path44 ? `Permission denied: ${path44}` : "Permission denied \u2014 check file permissions";
   }
   if (/EISDIR/i.test(msg)) {
     return "Expected a file but found a directory at the specified path";
@@ -10316,13 +11175,21 @@ var ToolRegistry = class {
           const field = issue.path.join(".") || "input";
           return `${field} (${issue.message.toLowerCase()})`;
         });
-        errorMessage = `Invalid tool input \u2014 ${fields.join(", ")}`;
+        errorMessage = `Invalid tool input for '${name}' \u2014 ${fields.join(", ")}`;
         const allUndefined = error.issues.every(
           (i) => i.message.toLowerCase().includes("received undefined")
         );
         if (allUndefined && error.issues.length > 1) {
           errorMessage += ". All parameters are missing \u2014 this is likely a JSON serialization error on our side. Please retry with the same arguments.";
         }
+        try {
+          const schema = zodToJsonSchema(tool.parameters);
+          errorMessage += `
+
+Expected schema for '${name}':
+${JSON.stringify(schema, null, 2)}`;
+        } catch {
+        }
       } else if (isCocoError(error)) {
         const causeMsg = error.cause instanceof Error ? error.cause.message : "";
         const isRawEnoent = causeMsg.startsWith("ENOENT:");
@@ -11512,8 +12379,8 @@ function createLLMAdapter2(context) {
         type: "done"
       };
     },
-    countTokens(text) {
-      return Math.ceil(text.length / 4);
+    countTokens(text2) {
+      return Math.ceil(text2.length / 4);
     },
     getContextWindow() {
       return 2e5;
@@ -13581,30 +14448,110 @@ var GEMINI_BUDGET = {
   medium: 8e3,
   high: 16e3
 };
-function isAnthropicThinkingModel(model) {
-  const m = model.toLowerCase();
+function isAnthropicThinkingModel(model2) {
+  const m = model2.toLowerCase();
   if (m === "kimi-for-coding") return false;
   return m.includes("claude-3-7") || m.includes("claude-opus-4") || m.includes("claude-sonnet-4") || m.includes("claude-haiku-4-5") || m.includes("claude-4");
 }
-function isOpenAIReasoningModel(model) {
-  const m = model.toLowerCase();
+function isAnthropicAdaptiveThinkingModel(model2) {
+  const m = model2.toLowerCase();
+  return m.includes("claude-opus-4-8") || m.includes("claude-opus-4-7") || m.includes("claude-opus-4-6") || m.includes("claude-sonnet-4-6");
+}
+function isOpenAIReasoningModel(model2) {
+  const m = model2.toLowerCase();
   return m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.startsWith("gpt-5") || m.includes("codex");
 }
-function isGeminiThinkingModel(model) {
-  const m = model.toLowerCase();
-  return m.includes("gemini-2.5-pro") || m.includes("gemini-2.5-flash") || m.includes("gemini-3") && !m.includes("flash-lite") || m.includes("gemini-2.0-flash-thinking");
+function isGeminiThinkingModel(model2) {
+  const m = model2.toLowerCase();
+  return m.includes("gemini-2.5-pro") || m.includes("gemini-2.5-flash") || m.includes("gemini-3") || m.includes("gemini-2.0-flash-thinking");
+}
+function isGeminiLevelThinkingModel(model2) {
+  return model2.toLowerCase().includes("gemini-3");
 }
-function isKimiThinkingModel(model) {
-  const m = model.toLowerCase();
+function isKimiThinkingModel(model2) {
+  const m = model2.toLowerCase();
   return m.includes("kimi-k2") || m === "kimi-latest";
 }
+var UNSUPPORTED = {
+  supported: false,
+  kinds: [],
+  levels: ["off"],
+  defaultMode: "off"
+};
 var ANTHROPIC_CAPABILITY = {
-  budgetRange: { min: 1024, max: 64e3, default: ANTHROPIC_BUDGET.medium }};
+  supported: true,
+  kinds: ["budget"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  budgetRange: { min: 1024, max: 64e3, default: ANTHROPIC_BUDGET.medium },
+  defaultMode: "off"
+};
+var ANTHROPIC_ADAPTIVE_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  defaultMode: "off"
+};
+var OPENAI_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  defaultMode: "medium"
+};
 var GEMINI_CAPABILITY = {
-  budgetRange: { min: 0, max: 32e3}};
-function mapToAnthropic(mode, model) {
+  supported: true,
+  kinds: ["budget"],
+  levels: ["off", "auto", "low", "medium", "high"],
+  budgetRange: { min: 0, max: 32e3, default: GEMINI_BUDGET.medium },
+  defaultMode: "auto"
+};
+var GEMINI_LEVEL_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["auto", "low", "medium", "high"],
+  defaultMode: "auto"
+};
+var KIMI_CAPABILITY = {
+  supported: true,
+  kinds: ["effort"],
+  levels: ["off", "auto"],
+  defaultMode: "off"
+};
+function getThinkingCapability(provider, model2) {
+  switch (provider) {
+    case "anthropic":
+    case "kimi-code":
+      if (isAnthropicAdaptiveThinkingModel(model2)) return ANTHROPIC_ADAPTIVE_CAPABILITY;
+      return isAnthropicThinkingModel(model2) ? ANTHROPIC_CAPABILITY : UNSUPPORTED;
+    case "openai":
+      return isOpenAIReasoningModel(model2) ? OPENAI_CAPABILITY : UNSUPPORTED;
+    case "kimi":
+      return isKimiThinkingModel(model2) ? KIMI_CAPABILITY : UNSUPPORTED;
+    case "gemini":
+    case "vertex":
+      if (isGeminiLevelThinkingModel(model2)) return GEMINI_LEVEL_CAPABILITY;
+      return isGeminiThinkingModel(model2) ? GEMINI_CAPABILITY : UNSUPPORTED;
+    case "copilot":
+    case "groq":
+    case "openrouter":
+    case "mistral":
+    case "deepseek":
+    case "together":
+    case "huggingface":
+    case "qwen":
+    case "lmstudio":
+    case "ollama":
+    case "codex":
+      return UNSUPPORTED;
+    default:
+      return UNSUPPORTED;
+  }
+}
+function mapToAnthropic(mode, model2) {
   if (!mode || mode === "off") return void 0;
-  if (!isAnthropicThinkingModel(model)) return void 0;
+  if (!isAnthropicThinkingModel(model2)) return void 0;
+  if (isAnthropicAdaptiveThinkingModel(model2)) {
+    return { type: "adaptive" };
+  }
   const cap = ANTHROPIC_CAPABILITY;
   const { min, max } = cap.budgetRange;
   if (typeof mode === "object") {
@@ -13620,9 +14567,20 @@ function mapToAnthropic(mode, model) {
   if (budget === void 0) return void 0;
   return { type: "enabled", budget_tokens: budget };
 }
-function mapToOpenAIEffort(mode, model) {
+function mapToAnthropicEffort(mode, model2) {
+  if (!mode || mode === "off" || mode === "auto") return void 0;
+  if (!isAnthropicAdaptiveThinkingModel(model2)) return void 0;
+  if (typeof mode === "object") {
+    if (mode.budget <= 2048) return "low";
+    if (mode.budget <= 8e3) return "medium";
+    return "high";
+  }
+  if (mode === "low" || mode === "medium" || mode === "high") return mode;
+  return void 0;
+}
+function mapToOpenAIEffort(mode, model2) {
   if (!mode || mode === "off") return void 0;
-  if (!isOpenAIReasoningModel(model)) return void 0;
+  if (!isOpenAIReasoningModel(model2)) return void 0;
   if (typeof mode === "object") {
     const { budget } = mode;
     if (budget <= 2048) return "low";
@@ -13633,8 +14591,9 @@ function mapToOpenAIEffort(mode, model) {
   if (mode === "low" || mode === "medium" || mode === "high") return mode;
   return void 0;
 }
-function mapToGeminiBudget(mode, model) {
-  if (!isGeminiThinkingModel(model)) return void 0;
+function mapToGeminiBudget(mode, model2) {
+  if (isGeminiLevelThinkingModel(model2)) return void 0;
+  if (!isGeminiThinkingModel(model2)) return void 0;
   if (!mode) return void 0;
   if (mode === "off") return 0;
   if (mode === "auto") return -1;
@@ -13649,15 +14608,33 @@ function mapToGeminiBudget(mode, model) {
   };
   return budgetMap[mode];
 }
-function mapToKimiExtraBody(mode, model) {
-  if (!isKimiThinkingModel(model)) return void 0;
+function mapToGeminiThinkingConfig(mode, model2) {
+  if (isGeminiLevelThinkingModel(model2)) {
+    if (!mode || mode === "auto") return void 0;
+    if (mode === "off") return { thinkingLevel: "low" };
+    if (mode === "low" || mode === "medium" || mode === "high") {
+      return { thinkingLevel: mode };
+    }
+    if (typeof mode === "object") {
+      if (mode.budget <= 2048) return { thinkingLevel: "low" };
+      if (mode.budget <= 8e3) return { thinkingLevel: "medium" };
+      return { thinkingLevel: "high" };
+    }
+    return void 0;
+  }
+  const thinkingBudget = mapToGeminiBudget(mode, model2);
+  return thinkingBudget !== void 0 ? { thinkingBudget } : void 0;
+}
+function mapToKimiExtraBody(mode, model2) {
+  if (!isKimiThinkingModel(model2)) return void 0;
   const effectiveMode = mode ?? "off";
   const enabled = effectiveMode !== "off";
   return { thinking: { type: enabled ? "enabled" : "disabled" } };
 }
 
 // src/providers/anthropic.ts
-var DEFAULT_MODEL = "claude-opus-4-6";
+init_catalog();
+var DEFAULT_MODEL = getCatalogDefaultModel("anthropic");
 var CONTEXT_WINDOWS = {
   // Kimi Code model (Anthropic-compatible endpoint)
   "kimi-for-coding": 131072,
@@ -13683,6 +14660,20 @@ var CONTEXT_WINDOWS = {
   "claude-3-sonnet-20240229": 2e5,
   "claude-3-haiku-20240307": 2e5
 };
+function getAnthropicMaxTokens(baseMaxTokens, thinkingParam) {
+  if (thinkingParam?.type === "enabled") {
+    return Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024);
+  }
+  return baseMaxTokens;
+}
+function getAnthropicTemperature(thinkingParam, configuredTemperature) {
+  if (thinkingParam?.type === "enabled") return 1;
+  return configuredTemperature;
+}
+function getAnthropicOutputConfig(mode, model2) {
+  const effort = mapToAnthropicEffort(mode, model2);
+  return effort ? { effort } : void 0;
+}
 var AnthropicProvider = class {
   id;
   name;
@@ -13717,19 +14708,22 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-        const thinkingParam = mapToAnthropic(options?.thinking, model);
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+        const thinkingParam = mapToAnthropic(options?.thinking, model2);
+        const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
         const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
         const response = await this.client.messages.create({
-          model,
-          // Anthropic requires max_tokens > budget_tokens
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          // Anthropic requires temperature=1 when thinking is enabled
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
           stop_sequences: options?.stopSequences,
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         });
         return {
           id: response.id,
@@ -13753,18 +14747,23 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-        const thinkingParam = mapToAnthropic(options?.thinking, model);
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+        const thinkingParam = mapToAnthropic(options?.thinking, model2);
+        const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
         const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
         const response = await this.client.messages.create({
-          model,
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
           tools: this.convertTools(options.tools),
           tool_choice: options.toolChoice ? this.convertToolChoice(options.toolChoice) : void 0,
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         });
         const toolCalls = this.extractToolCalls(response.content);
         return {
@@ -13790,17 +14789,22 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-      const thinkingParam = mapToAnthropic(options?.thinking, model);
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+      const thinkingParam = mapToAnthropic(options?.thinking, model2);
+      const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
       const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
       const stream = await this.client.messages.stream(
         {
-          model,
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         },
         { signal: options?.signal }
       );
@@ -13856,19 +14860,24 @@ var AnthropicProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL;
-      const thinkingParam = mapToAnthropic(options?.thinking, model);
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL;
+      const thinkingParam = mapToAnthropic(options?.thinking, model2);
+      const outputConfig = getAnthropicOutputConfig(options?.thinking, model2);
       const baseMaxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
       const stream = await this.client.messages.stream(
         {
-          model,
-          max_tokens: thinkingParam ? Math.max(baseMaxTokens, thinkingParam.budget_tokens + 1024) : baseMaxTokens,
-          temperature: thinkingParam ? 1 : options?.temperature ?? this.config.temperature ?? 0,
+          model: model2,
+          max_tokens: getAnthropicMaxTokens(baseMaxTokens, thinkingParam),
+          temperature: getAnthropicTemperature(
+            thinkingParam,
+            options?.temperature ?? this.config.temperature ?? 0
+          ),
           system: this.extractSystem(messages, options?.system),
           messages: this.convertMessages(messages),
           tools: this.convertTools(options.tools),
           tool_choice: options.toolChoice ? this.convertToolChoice(options.toolChoice) : void 0,
-          ...thinkingParam && { thinking: thinkingParam }
+          ...thinkingParam && { thinking: thinkingParam },
+          ...outputConfig && { output_config: outputConfig }
         },
         { signal: options?.signal }
       );
@@ -13993,33 +15002,38 @@ var AnthropicProvider = class {
    *
    * This heuristic analyzes the text to provide a better estimate.
    */
-  countTokens(text) {
-    if (!text) return 0;
+  countTokens(text2) {
+    if (!text2) return 0;
     const codePatterns = /[{}[\]();=<>!&|+\-*/]/g;
     const whitespacePattern = /\s/g;
     const wordPattern = /\b\w+\b/g;
-    const codeChars = (text.match(codePatterns) || []).length;
-    const whitespace = (text.match(whitespacePattern) || []).length;
-    const words = (text.match(wordPattern) || []).length;
-    const isCodeLike = codeChars > text.length * 0.05;
+    const codeChars = (text2.match(codePatterns) || []).length;
+    const whitespace = (text2.match(whitespacePattern) || []).length;
+    const words = (text2.match(wordPattern) || []).length;
+    const isCodeLike = codeChars > text2.length * 0.05;
     let charsPerToken;
     if (isCodeLike) {
       charsPerToken = 3.5;
-    } else if (whitespace > text.length * 0.3) {
+    } else if (whitespace > text2.length * 0.3) {
       charsPerToken = 5;
     } else {
       charsPerToken = 4.5;
     }
     const wordBasedEstimate = words * 1.3;
-    const charBasedEstimate = text.length / charsPerToken;
+    const charBasedEstimate = text2.length / charsPerToken;
     return Math.ceil((wordBasedEstimate + charBasedEstimate) / 2);
   }
   /**
    * Get context window size
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL;
-    return CONTEXT_WINDOWS[model] ?? 2e5;
+    const model2 = this.config.model ?? DEFAULT_MODEL;
+    const provider = this.id === "kimi-code" ? "kimi-code" : "anthropic";
+    const catalogWindow = getCatalogContextWindow(provider, model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS[model2] ?? 2e5;
   }
   /**
    * Check if provider is available
@@ -14060,8 +15074,8 @@ var AnthropicProvider = class {
     const systemMsg = messages.find((m) => m.role === "system");
     if (!systemMsg) return void 0;
     if (typeof systemMsg.content === "string") return systemMsg.content;
-    const text = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    return text || void 0;
+    const text2 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return text2 || void 0;
   }
   /**
    * Convert messages to Anthropic format
@@ -14269,15 +15283,15 @@ var ChatToolCallAssembler = class {
     if (delta.function?.name) {
       builder.name = delta.function.name;
     }
-    const text = delta.function?.arguments ?? "";
-    if (!text) return { started };
-    builder.arguments += text;
+    const text2 = delta.function?.arguments ?? "";
+    if (!text2) return { started };
+    builder.arguments += text2;
     return {
       started,
       argumentDelta: {
         id: builder.id,
         name: builder.name,
-        text
+        text: text2
       }
     };
   }
@@ -14368,8 +15382,132 @@ var ResponsesToolCallAssembler = class {
   }
 };
 
+// src/providers/model-tier.ts
+var TIER_CONFIGS = {
+  mini: {
+    maxTools: 12,
+    parallelToolCalls: false,
+    compactionThreshold: 0.5,
+    supportsCoT: false
+  },
+  standard: {
+    maxTools: 40,
+    parallelToolCalls: true,
+    compactionThreshold: 0.75,
+    supportsCoT: true
+  },
+  advanced: {
+    maxTools: 128,
+    parallelToolCalls: true,
+    compactionThreshold: 0.8,
+    supportsCoT: true
+  }
+};
+var ANTHROPIC_TIERS = [
+  // Haiku — mini tier
+  { prefix: "claude-haiku", tier: "mini" },
+  { prefix: "claude-3-haiku", tier: "mini" },
+  // Sonnet / Claude 3.5 — standard tier
+  { prefix: "claude-3-5-sonnet", tier: "standard" },
+  { prefix: "claude-3-7-sonnet", tier: "standard" },
+  { prefix: "claude-sonnet", tier: "standard" },
+  // Opus — advanced tier
+  { prefix: "claude-opus", tier: "advanced" },
+  { prefix: "claude-3-opus", tier: "advanced" }
+  // claude-4+ (future) — default to standard unless matched above
+];
+var OPENAI_TIERS = [
+  // Mini models
+  { prefix: "gpt-4o-mini", tier: "mini" },
+  { prefix: "gpt-5-mini", tier: "mini" },
+  { prefix: "gpt-5.4-mini", tier: "mini" },
+  { prefix: "gpt-5.3-mini", tier: "mini" },
+  { prefix: "o1-mini", tier: "mini" },
+  { prefix: "o3-mini", tier: "mini" },
+  // Advanced / reasoning models
+  { prefix: "o1", tier: "advanced" },
+  { prefix: "o3", tier: "advanced" },
+  { prefix: "o4", tier: "advanced" },
+  { prefix: "gpt-4.1", tier: "advanced" },
+  { prefix: "gpt-5.4-codex", tier: "advanced" },
+  { prefix: "gpt-5.3-codex", tier: "advanced" },
+  { prefix: "gpt-5.2-codex", tier: "advanced" },
+  { prefix: "gpt-5.1-codex", tier: "advanced" },
+  { prefix: "gpt-5.4", tier: "advanced" },
+  { prefix: "gpt-5.3", tier: "advanced" },
+  { prefix: "gpt-5.2", tier: "advanced" },
+  { prefix: "gpt-5.1", tier: "advanced" },
+  // GPT-5 catch-all (non-mini/codex) — advanced
+  { prefix: "gpt-5", tier: "advanced" },
+  // GPT-4o — standard
+  { prefix: "gpt-4o", tier: "standard" },
+  // GPT-4 — standard
+  { prefix: "gpt-4", tier: "standard" }
+];
+var GEMINI_TIERS = [
+  // Flash — mini tier
+  { prefix: "gemini-3-flash", tier: "mini" },
+  { prefix: "gemini-2.5-flash", tier: "mini" },
+  { prefix: "gemini-2.0-flash", tier: "mini" },
+  { prefix: "gemini-1.5-flash", tier: "mini" },
+  // Pro — standard/advanced
+  { prefix: "gemini-3.1-pro", tier: "advanced" },
+  { prefix: "gemini-3-pro", tier: "advanced" },
+  { prefix: "gemini-2.5-pro", tier: "standard" },
+  { prefix: "gemini-2.0-pro", tier: "standard" },
+  { prefix: "gemini-1.5-pro", tier: "standard" }
+];
+var KIMI_TIERS = [
+  { prefix: "kimi-for-coding", tier: "advanced" },
+  { prefix: "kimi-k2", tier: "advanced" },
+  { prefix: "kimi-latest", tier: "standard" },
+  { prefix: "kimi", tier: "standard" }
+];
+var EVAL_TIERS = [
+  { prefix: "grok-code", tier: "standard" },
+  { prefix: "raptor", tier: "mini" },
+  { prefix: "goldeneye", tier: "standard" }
+];
+function matchTier(model2, table) {
+  const lower = model2.toLowerCase();
+  const sorted = [...table].sort((a, b) => b.prefix.length - a.prefix.length);
+  for (const { prefix, tier } of sorted) {
+    if (lower.startsWith(prefix.toLowerCase())) return tier;
+  }
+  return null;
+}
+function getModelTier(provider, model2) {
+  if (!model2) return "standard";
+  const p5 = provider.toLowerCase();
+  if (p5 === "anthropic") {
+    return matchTier(model2, ANTHROPIC_TIERS) ?? "standard";
+  }
+  if (p5 === "kimi-code") {
+    return matchTier(model2, KIMI_TIERS) ?? matchTier(model2, ANTHROPIC_TIERS) ?? "standard";
+  }
+  if (p5 === "openai" || p5 === "copilot" || p5 === "codex") {
+    if (model2.startsWith("claude-")) {
+      return matchTier(model2, ANTHROPIC_TIERS) ?? "standard";
+    }
+    const evalMatch = matchTier(model2, EVAL_TIERS);
+    if (evalMatch) return evalMatch;
+    return matchTier(model2, OPENAI_TIERS) ?? "standard";
+  }
+  if (p5 === "gemini" || p5 === "vertex") {
+    return matchTier(model2, GEMINI_TIERS) ?? "standard";
+  }
+  if (p5 === "kimi" || p5 === "moonshot") {
+    return matchTier(model2, KIMI_TIERS) ?? "standard";
+  }
+  return "standard";
+}
+function getTierConfig(provider, model2) {
+  return TIER_CONFIGS[getModelTier(provider, model2)];
+}
+
 // src/providers/openai.ts
-var DEFAULT_MODEL2 = "gpt-5.3-codex";
+init_catalog();
+var DEFAULT_MODEL2 = getCatalogDefaultModel("openai");
 var CONTEXT_WINDOWS2 = {
   // OpenAI models
   "gpt-4o": 128e3,
@@ -14480,14 +15618,14 @@ var LOCAL_MODEL_PATTERNS = [
   "starcoder"
 ];
 var MODELS_WITH_THINKING_MODE = ["kimi-k2.5", "kimi-k2-0324", "kimi-latest"];
-function needsResponsesApi(model) {
-  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model === "o3";
+function needsResponsesApi(model2) {
+  return model2.includes("codex") || model2.startsWith("gpt-5") || model2.startsWith("o4-") || model2 === "o3";
 }
-function needsMaxCompletionTokens(model) {
-  return model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4") || model.startsWith("gpt-4o") || model.startsWith("gpt-4.1") || model.startsWith("gpt-5") || model.startsWith("chatgpt-4o");
+function needsMaxCompletionTokens(model2) {
+  return model2.startsWith("o1") || model2.startsWith("o3") || model2.startsWith("o4") || model2.startsWith("gpt-4o") || model2.startsWith("gpt-4.1") || model2.startsWith("gpt-5") || model2.startsWith("chatgpt-4o");
 }
-function buildMaxTokensParam(model, maxTokens) {
-  if (needsMaxCompletionTokens(model)) {
+function buildMaxTokensParam(model2, maxTokens) {
+  if (needsMaxCompletionTokens(model2)) {
     return { max_completion_tokens: maxTokens };
   }
   return { max_tokens: maxTokens };
@@ -14529,26 +15667,45 @@ var OpenAIProvider = class {
   /**
    * Check if a model supports temperature parameter
    */
-  supportsTemperature(model) {
-    return !MODELS_WITHOUT_TEMPERATURE.some((m) => model.toLowerCase().includes(m.toLowerCase()));
+  supportsTemperature(model2) {
+    return !MODELS_WITHOUT_TEMPERATURE.some((m) => model2.toLowerCase().includes(m.toLowerCase()));
   }
   /**
    * Whether this provider instance supports the Responses API for the given model.
    * Subclasses (e.g. CopilotProvider) can override to force Chat Completions
    * when their endpoint does not expose /v1/responses.
    */
-  modelNeedsResponsesApi(model) {
-    return needsResponsesApi(model);
+  modelNeedsResponsesApi(model2) {
+    return this.id === "openai" && needsResponsesApi(model2);
+  }
+  /**
+   * Map thinking mode to Chat Completions reasoning_effort.
+   * Subclasses can override when an OpenAI-compatible endpoint exposes GPT-5
+   * models but cannot safely combine reasoning_effort with tool calls.
+   */
+  getChatCompletionsReasoningEffort(model2, thinking, _hasTools) {
+    const capability = getThinkingCapability(this.id, model2);
+    if (!capability.supported || !capability.kinds.includes("effort")) {
+      return void 0;
+    }
+    return mapToOpenAIEffort(thinking, model2);
+  }
+  getResponsesReasoningEffort(model2, thinking) {
+    const capability = getThinkingCapability(this.id, model2);
+    if (!capability.supported || !capability.kinds.includes("effort")) {
+      return void 0;
+    }
+    return mapToOpenAIEffort(thinking, model2);
   }
   /**
    * Get extra body parameters for API calls.
    * Honors the user's ThinkingMode for Kimi models; defaults to disabled
    * (preserving existing behavior) when no mode is specified.
    */
-  getExtraBody(model, thinking) {
-    const kimiBody = mapToKimiExtraBody(thinking, model);
+  getExtraBody(model2, thinking) {
+    const kimiBody = mapToKimiExtraBody(thinking, model2);
     if (kimiBody) return kimiBody;
-    if (MODELS_WITH_THINKING_MODE.some((m) => model.toLowerCase().includes(m.toLowerCase()))) {
+    if (MODELS_WITH_THINKING_MODE.some((m) => model2.toLowerCase().includes(m.toLowerCase()))) {
       return { thinking: { type: "disabled" } };
     }
     return void 0;
@@ -14558,18 +15715,22 @@ var OpenAIProvider = class {
    */
   async chat(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       return this.chatViaResponses(messages, options);
     }
     return withRetry(async () => {
       try {
-        const supportsTemp = this.supportsTemperature(model);
+        const supportsTemp = this.supportsTemperature(model2);
         const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const reasoningEffort = this.getChatCompletionsReasoningEffort(
+          model2,
+          options?.thinking,
+          false
+        );
         const response = await this.client.chat.completions.create({
-          model,
-          ...buildMaxTokensParam(model, maxTokens),
+          model: model2,
+          ...buildMaxTokensParam(model2, maxTokens),
           messages: this.convertMessages(messages, options?.system),
           stop: options?.stopSequences,
           ...supportsTemp && {
@@ -14598,22 +15759,29 @@ var OpenAIProvider = class {
    */
   async chatWithTools(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       return this.chatWithToolsViaResponses(messages, options);
     }
+    const tierCfg = getTierConfig(this.id, model2);
     return withRetry(async () => {
       try {
-        const supportsTemp = this.supportsTemperature(model);
-        const extraBody = this.getExtraBody(model, options?.thinking);
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const supportsTemp = this.supportsTemperature(model2);
+        const extraBody = this.getExtraBody(model2, options?.thinking);
+        const reasoningEffort = this.getChatCompletionsReasoningEffort(
+          model2,
+          options?.thinking,
+          true
+        );
         const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
+        const tools = this.limitTools(options.tools, tierCfg.maxTools);
         const requestParams = {
-          model,
-          ...buildMaxTokensParam(model, maxTokens),
+          model: model2,
+          ...buildMaxTokensParam(model2, maxTokens),
           messages: this.convertMessages(messages, options?.system),
-          tools: this.convertTools(options.tools),
-          tool_choice: this.convertToolChoice(options.toolChoice)
+          tools: this.convertTools(tools),
+          tool_choice: this.convertToolChoice(options.toolChoice),
+          parallel_tool_calls: tierCfg.parallelToolCalls
         };
         if (supportsTemp) {
           requestParams.temperature = options?.temperature ?? this.config.temperature ?? 0;
@@ -14650,18 +15818,22 @@ var OpenAIProvider = class {
    */
   async *stream(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       yield* this.streamViaResponses(messages, options);
       return;
     }
     try {
-      const supportsTemp = this.supportsTemperature(model);
+      const supportsTemp = this.supportsTemperature(model2);
       const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const reasoningEffort = this.getChatCompletionsReasoningEffort(
+        model2,
+        options?.thinking,
+        false
+      );
       const stream = await this.client.chat.completions.create({
-        model,
-        ...buildMaxTokensParam(model, maxTokens),
+        model: model2,
+        ...buildMaxTokensParam(model2, maxTokens),
         messages: this.convertMessages(messages, options?.system),
         stream: true,
         ...supportsTemp && { temperature: options?.temperature ?? this.config.temperature ?? 0 },
@@ -14688,23 +15860,30 @@ var OpenAIProvider = class {
    */
   async *streamWithTools(messages, options) {
     this.ensureInitialized();
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
-    if (this.modelNeedsResponsesApi(model)) {
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+    if (this.modelNeedsResponsesApi(model2)) {
       yield* this.streamWithToolsViaResponses(messages, options);
       return;
     }
+    const tierCfg = getTierConfig(this.id, model2);
     let timeoutTriggered = false;
     try {
-      const supportsTemp = this.supportsTemperature(model);
-      const extraBody = this.getExtraBody(model, options?.thinking);
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const supportsTemp = this.supportsTemperature(model2);
+      const extraBody = this.getExtraBody(model2, options?.thinking);
+      const reasoningEffort = this.getChatCompletionsReasoningEffort(
+        model2,
+        options?.thinking,
+        true
+      );
       const maxTokens = options?.maxTokens ?? this.config.maxTokens ?? 8192;
+      const tools = this.limitTools(options.tools, tierCfg.maxTools);
       const requestParams = {
-        model,
-        ...buildMaxTokensParam(model, maxTokens),
+        model: model2,
+        ...buildMaxTokensParam(model2, maxTokens),
         messages: this.convertMessages(messages, options?.system),
-        tools: this.convertTools(options.tools),
+        tools: this.convertTools(tools),
         tool_choice: this.convertToolChoice(options.toolChoice),
+        parallel_tool_calls: tierCfg.parallelToolCalls,
         stream: true
       };
       if (supportsTemp) {
@@ -14821,13 +16000,13 @@ var OpenAIProvider = class {
    * Check if current model is a local model (LM Studio, Ollama, etc.)
    */
   isLocalModel() {
-    const model = (this.config.model ?? "").toLowerCase();
+    const model2 = (this.config.model ?? "").toLowerCase();
     const baseUrl = (this.config.baseUrl ?? "").toLowerCase();
     if (baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1") || baseUrl.includes(":1234") || // LM Studio default
     baseUrl.includes(":11434")) {
       return true;
     }
-    return LOCAL_MODEL_PATTERNS.some((pattern) => model.includes(pattern));
+    return LOCAL_MODEL_PATTERNS.some((pattern) => model2.includes(pattern));
   }
   /**
    * Count tokens (improved heuristic for OpenAI and local models)
@@ -14847,23 +16026,23 @@ var OpenAIProvider = class {
    * For accurate counting, use the model's native tokenizer.
    * This heuristic provides a reasonable estimate without dependencies.
    */
-  countTokens(text) {
-    if (!text) return 0;
+  countTokens(text2) {
+    if (!text2) return 0;
     const codePatterns = /[{}[\]();=<>!&|+\-*/]/g;
     const whitespacePattern = /\s/g;
     const wordPattern = /\b\w+\b/g;
     const nonAsciiPattern = /[^\x00-\x7F]/g;
-    const codeChars = (text.match(codePatterns) || []).length;
-    const whitespace = (text.match(whitespacePattern) || []).length;
-    const words = (text.match(wordPattern) || []).length;
-    const nonAscii = (text.match(nonAsciiPattern) || []).length;
-    const isCodeLike = codeChars > text.length * 0.05;
+    const codeChars = (text2.match(codePatterns) || []).length;
+    const whitespace = (text2.match(whitespacePattern) || []).length;
+    const words = (text2.match(wordPattern) || []).length;
+    const nonAscii = (text2.match(nonAsciiPattern) || []).length;
+    const isCodeLike = codeChars > text2.length * 0.05;
     const isLocal = this.isLocalModel();
     let charsPerToken;
     if (isLocal) {
       if (isCodeLike) {
         charsPerToken = 3.2;
-      } else if (nonAscii > text.length * 0.1) {
+      } else if (nonAscii > text2.length * 0.1) {
         charsPerToken = 2;
       } else {
         charsPerToken = 3.5;
@@ -14871,7 +16050,7 @@ var OpenAIProvider = class {
     } else {
       if (isCodeLike) {
         charsPerToken = 3.3;
-      } else if (whitespace > text.length * 0.3) {
+      } else if (whitespace > text2.length * 0.3) {
         charsPerToken = 4.5;
       } else {
         charsPerToken = 4;
@@ -14879,7 +16058,7 @@ var OpenAIProvider = class {
     }
     const tokensPerWord = isLocal ? 1.4 : 1.3;
     const wordBasedEstimate = words * tokensPerWord;
-    const charBasedEstimate = text.length / charsPerToken;
+    const charBasedEstimate = text2.length / charsPerToken;
     const weight = isCodeLike ? 0.7 : 0.5;
     return Math.ceil(charBasedEstimate * weight + wordBasedEstimate * (1 - weight));
   }
@@ -14891,11 +16070,15 @@ var OpenAIProvider = class {
    * conventions (e.g., "qwen3-coder-8b" vs "qwen3-coder-8b-instruct").
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL2;
-    if (CONTEXT_WINDOWS2[model]) {
-      return CONTEXT_WINDOWS2[model];
+    const model2 = this.config.model ?? DEFAULT_MODEL2;
+    if (CONTEXT_WINDOWS2[model2]) {
+      return CONTEXT_WINDOWS2[model2];
     }
-    const modelLower = model.toLowerCase();
+    const catalogWindow = getCatalogContextWindow(this.id, model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    const modelLower = model2.toLowerCase();
     for (const [key, value] of Object.entries(CONTEXT_WINDOWS2)) {
       if (modelLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelLower)) {
         return value;
@@ -14940,19 +16123,19 @@ var OpenAIProvider = class {
       return true;
     } catch {
       try {
-        const model = this.config.model || DEFAULT_MODEL2;
-        if (this.modelNeedsResponsesApi(model)) {
+        const model2 = this.config.model || DEFAULT_MODEL2;
+        if (this.modelNeedsResponsesApi(model2)) {
           await this.client.responses.create({
-            model,
+            model: model2,
             input: [{ role: "user", content: [{ type: "input_text", text: "Hi" }] }],
             max_output_tokens: 1,
             store: false
           });
         } else {
           await this.client.chat.completions.create({
-            model,
+            model: model2,
             messages: [{ role: "user", content: "Hi" }],
-            ...buildMaxTokensParam(model, 1)
+            ...buildMaxTokensParam(model2, 1)
           });
         }
         return true;
@@ -15074,6 +16257,17 @@ var OpenAIProvider = class {
     }
     return content.filter((block) => block.type === "text").map((block) => block.text).join("");
   }
+  /**
+   * Limit the tool list to at most `max` entries.
+   * Built-in tools (those without an `mcp_server` tag) are prioritised over
+   * MCP tools so core capabilities are never dropped.
+   */
+  limitTools(tools, max) {
+    if (tools.length <= max) return tools;
+    const builtin = tools.filter((t) => !("serverName" in t && t.serverName));
+    const mcp = tools.filter((t) => "serverName" in t && t.serverName);
+    return [...builtin, ...mcp].slice(0, max);
+  }
   /**
    * Convert tools to OpenAI format
    */
@@ -15083,7 +16277,8 @@ var OpenAIProvider = class {
       function: {
         name: tool.name,
         description: truncateToolDescription(tool.description),
-        parameters: tool.input_schema
+        parameters: tool.input_schema,
+        strict: true
       }
     }));
   }
@@ -15177,12 +16372,12 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
         const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-        const supportsTemp = this.supportsTemperature(model);
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const supportsTemp = this.supportsTemperature(model2);
+        const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
         const response = await this.client.responses.create({
-          model,
+          model: model2,
           input,
           instructions: instructions ?? void 0,
           max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
@@ -15215,13 +16410,16 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     return withRetry(async () => {
       try {
-        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+        const tierCfg = getTierConfig(this.id, model2);
         const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-        const tools = this.convertToolsForResponses(options.tools);
-        const supportsTemp = this.supportsTemperature(model);
-        const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+        const tools = this.convertToolsForResponses(
+          this.limitTools(options.tools, tierCfg.maxTools)
+        );
+        const supportsTemp = this.supportsTemperature(model2);
+        const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
         const response = await this.client.responses.create({
-          model,
+          model: model2,
           input,
           instructions: instructions ?? void 0,
           tools,
@@ -15272,12 +16470,12 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const supportsTemp = this.supportsTemperature(model);
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const supportsTemp = this.supportsTemperature(model2);
+      const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
       const stream = await this.client.responses.create({
-        model,
+        model: model2,
         input,
         instructions: instructions ?? void 0,
         max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
@@ -15336,13 +16534,15 @@ var OpenAIProvider = class {
     this.ensureInitialized();
     let timeoutTriggered = false;
     try {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL2;
+      const tierCfg = getTierConfig(this.id, model2);
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const tools = options.tools.length > 0 ? this.convertToolsForResponses(options.tools) : void 0;
-      const supportsTemp = this.supportsTemperature(model);
-      const reasoningEffort = mapToOpenAIEffort(options?.thinking, model);
+      const limitedTools = this.limitTools(options.tools, tierCfg.maxTools);
+      const tools = limitedTools.length > 0 ? this.convertToolsForResponses(limitedTools) : void 0;
+      const supportsTemp = this.supportsTemperature(model2);
+      const reasoningEffort = this.getResponsesReasoningEffort(model2, options?.thinking);
       const requestParams = {
-        model,
+        model: model2,
         input,
         instructions: instructions ?? void 0,
         max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
@@ -15570,7 +16770,7 @@ var OpenAIProvider = class {
       name: tool.name,
       description: tool.description ? truncateToolDescription(tool.description) : void 0,
       parameters: tool.input_schema ?? null,
-      strict: false
+      strict: true
     }));
   }
 };
@@ -15597,8 +16797,9 @@ function createKimiProvider(config) {
 // src/providers/codex.ts
 init_errors();
 init_auth();
+init_catalog();
 var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-var DEFAULT_MODEL3 = "gpt-5.3-codex";
+var DEFAULT_MODEL3 = getCatalogDefaultModel("codex");
 var CONTEXT_WINDOWS3 = {
   "gpt-5.4-codex": 2e5,
   "gpt-5.3-codex": 2e5,
@@ -15665,16 +16866,23 @@ var CodexProvider = class {
   /**
    * Get context window size for a model
    */
-  getContextWindow(model) {
-    const m = model ?? this.config.model ?? DEFAULT_MODEL3;
-    return CONTEXT_WINDOWS3[m] ?? 128e3;
+  getContextWindow(model2) {
+    const m = model2 ?? this.config.model ?? DEFAULT_MODEL3;
+    if (CONTEXT_WINDOWS3[m]) {
+      return CONTEXT_WINDOWS3[m];
+    }
+    const catalogWindow = getCatalogContextWindow("codex", m, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return 128e3;
   }
   /**
    * Count tokens in text (approximate)
    * Uses GPT-4 approximation: ~4 chars per token
    */
-  countTokens(text) {
-    return Math.ceil(text.length / 4);
+  countTokens(text2) {
+    return Math.ceil(text2.length / 4);
   }
   /**
    * Check if provider is available (has valid OAuth tokens)
@@ -15802,9 +17010,9 @@ var CodexProvider = class {
   /**
    * Build the request body for the Codex Responses API
    */
-  buildRequestBody(model, input, instructions, options) {
+  buildRequestBody(model2, input, instructions, options) {
     const body = {
-      model,
+      model: model2,
       input,
       instructions: instructions ?? "You are a helpful coding assistant.",
       store: false,
@@ -15869,9 +17077,9 @@ var CodexProvider = class {
    */
   async chat(messages, options) {
     return withRetry(async () => {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const body = this.buildRequestBody(model, input, instructions, {
+      const body = this.buildRequestBody(model2, input, instructions, {
         maxTokens: options?.maxTokens,
         temperature: options?.temperature
       });
@@ -15902,7 +17110,7 @@ var CodexProvider = class {
         id: responseId,
         content,
         stopReason,
-        model,
+        model: model2,
         usage: { inputTokens, outputTokens }
       };
     }, this.retryConfig);
@@ -15912,9 +17120,9 @@ var CodexProvider = class {
    */
   async chatWithTools(messages, options) {
     return withRetry(async () => {
-      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+      const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
       const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-      const body = this.buildRequestBody(model, input, instructions, {
+      const body = this.buildRequestBody(model2, input, instructions, {
         tools: options.tools,
         maxTokens: options?.maxTokens
       });
@@ -15989,7 +17197,7 @@ var CodexProvider = class {
         id: responseId,
         content,
         stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn",
-        model,
+        model: model2,
         usage: { inputTokens, outputTokens },
         toolCalls
       };
@@ -15999,9 +17207,9 @@ var CodexProvider = class {
    * Stream a chat response (no tools)
    */
   async *stream(messages, options) {
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
     const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-    const body = this.buildRequestBody(model, input, instructions, {
+    const body = this.buildRequestBody(model2, input, instructions, {
       maxTokens: options?.maxTokens
     });
     const response = await this.makeRequest(body);
@@ -16061,9 +17269,9 @@ var CodexProvider = class {
    * item_id which references the output item's id field, not call_id.
    */
   async *streamWithTools(messages, options) {
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const model2 = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
     const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
-    const body = this.buildRequestBody(model, input, instructions, {
+    const body = this.buildRequestBody(model2, input, instructions, {
       tools: options.tools,
       maxTokens: options?.maxTokens
     });
@@ -16212,6 +17420,7 @@ var CodexProvider = class {
 // src/providers/copilot.ts
 init_errors();
 init_copilot();
+init_catalog();
 var CONTEXT_WINDOWS4 = {
   // Claude models — Copilot API caps these at 168 000 (not 200 000 like Anthropic direct)
   "claude-sonnet-4.6": 168e3,
@@ -16245,10 +17454,10 @@ var CONTEXT_WINDOWS4 = {
   "raptor-mini": 4e5,
   goldeneye: 4e5
 };
-var DEFAULT_MODEL4 = "claude-sonnet-4.6";
-function normalizeModel(model) {
-  if (typeof model !== "string") return void 0;
-  const trimmed = model.trim();
+var DEFAULT_MODEL4 = getCatalogDefaultModel("copilot");
+function normalizeModel(model2) {
+  if (typeof model2 !== "string") return void 0;
+  const trimmed = model2.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
 var COPILOT_HEADERS = {
@@ -16355,16 +17564,31 @@ var CopilotProvider = class extends OpenAIProvider {
   modelNeedsResponsesApi(_model) {
     return false;
   }
-  countTokens(text) {
-    if (!text) return 0;
-    return Math.ceil(text.length / 3.5);
+  /**
+   * Copilot's OpenAI-compatible endpoint currently routes through
+   * Chat Completions. For GPT-5.x models, combining function tools with
+   * reasoning_effort is rejected by the upstream API. Keep tools working by
+   * omitting reasoning_effort on tool calls instead of advertising a broken
+   * combination.
+   */
+  getChatCompletionsReasoningEffort(_model, _thinking, hasTools) {
+    if (hasTools) return void 0;
+    return void 0;
+  }
+  countTokens(text2) {
+    if (!text2) return 0;
+    return Math.ceil(text2.length / 3.5);
   }
   /**
    * Get context window for the current model
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL4;
-    return CONTEXT_WINDOWS4[model] ?? 128e3;
+    const model2 = this.config.model ?? DEFAULT_MODEL4;
+    const catalogWindow = getCatalogContextWindow("copilot", model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS4[model2] ?? 128e3;
   }
   /**
    * Check if Copilot credentials are available
@@ -16381,7 +17605,8 @@ var CopilotProvider = class extends OpenAIProvider {
 
 // src/providers/gemini.ts
 init_errors();
-var DEFAULT_MODEL5 = "gemini-3.1-pro-preview";
+init_catalog();
+var DEFAULT_MODEL5 = getCatalogDefaultModel("gemini");
 var SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
 var CONTEXT_WINDOWS5 = {
   "gemini-3.1-pro-preview": 1e6,
@@ -16445,9 +17670,9 @@ var GeminiProvider = class {
       });
       let streamStopReason = "end_turn";
       for await (const chunk of stream) {
-        const text = chunk.text;
-        if (text) {
-          yield { type: "text", text };
+        const text2 = chunk.text;
+        if (text2) {
+          yield { type: "text", text: text2 };
         }
         const finishReason = chunk.candidates?.[0]?.finishReason;
         if (finishReason) {
@@ -16471,9 +17696,9 @@ var GeminiProvider = class {
       let fallbackToolCounter = 0;
       const emittedToolIds = /* @__PURE__ */ new Set();
       for await (const chunk of stream) {
-        const text = chunk.text;
-        if (text) {
-          yield { type: "text", text };
+        const text2 = chunk.text;
+        if (text2) {
+          yield { type: "text", text: text2 };
         }
         const toolCalls = this.extractToolCalls(chunk, { includeLegacyFunctionCalls: true });
         for (const toolCall of toolCalls) {
@@ -16508,13 +17733,17 @@ var GeminiProvider = class {
       throw this.handleError(error);
     }
   }
-  countTokens(text) {
-    if (!text) return 0;
-    return Math.ceil(text.length / 3.5);
+  countTokens(text2) {
+    if (!text2) return 0;
+    return Math.ceil(text2.length / 3.5);
   }
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL5;
-    return CONTEXT_WINDOWS5[model] ?? 1e6;
+    const model2 = this.config.model ?? DEFAULT_MODEL5;
+    const catalogWindow = getCatalogContextWindow("gemini", model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS5[model2] ?? 1e6;
   }
   async isAvailable() {
     if (!this.client) return false;
@@ -16535,20 +17764,20 @@ var GeminiProvider = class {
       });
     }
   }
-  getModel(model) {
-    return model ?? this.config.model ?? DEFAULT_MODEL5;
+  getModel(model2) {
+    return model2 ?? this.config.model ?? DEFAULT_MODEL5;
   }
   buildConfig(messages, options, tools, toolChoice) {
-    const model = this.getModel(options?.model);
-    const thinkingBudget = mapToGeminiBudget(options?.thinking, model);
+    const model2 = this.getModel(options?.model);
+    const thinkingConfig = mapToGeminiThinkingConfig(options?.thinking, model2);
     const config = {
       maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
       temperature: options?.temperature ?? this.config.temperature ?? 0,
       stopSequences: options?.stopSequences,
       systemInstruction: this.extractSystem(messages, options?.system)
     };
-    if (thinkingBudget !== void 0) {
-      config.thinkingConfig = { thinkingBudget };
+    if (thinkingConfig !== void 0) {
+      config.thinkingConfig = thinkingConfig;
     }
     if (tools && tools.length > 0) {
       config.tools = [{ functionDeclarations: this.convertTools(tools) }];
@@ -16563,8 +17792,8 @@ var GeminiProvider = class {
     const systemMsg = messages.find((m) => m.role === "system");
     if (!systemMsg) return void 0;
     if (typeof systemMsg.content === "string") return systemMsg.content;
-    const text = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    return text || void 0;
+    const text2 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return text2 || void 0;
   }
   convertContents(messages) {
     const toolNameByUseId = this.buildToolUseNameMap(messages);
@@ -16687,7 +17916,7 @@ var GeminiProvider = class {
       })
     }));
   }
-  parseResponse(response, model) {
+  parseResponse(response, model2) {
     const usage = response.usageMetadata;
     return {
       id: `gemini-${Date.now()}`,
@@ -16697,10 +17926,10 @@ var GeminiProvider = class {
         inputTokens: usage?.promptTokenCount ?? 0,
         outputTokens: usage?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model)
+      model: this.getModel(model2)
     };
   }
-  parseResponseWithTools(response, model) {
+  parseResponseWithTools(response, model2) {
     const usage = response.usageMetadata;
     const toolCalls = this.extractToolCalls(response, { includeLegacyFunctionCalls: true });
     return {
@@ -16711,7 +17940,7 @@ var GeminiProvider = class {
         inputTokens: usage?.promptTokenCount ?? 0,
         outputTokens: usage?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model),
+      model: this.getModel(model2),
       toolCalls
     };
   }
@@ -16750,7 +17979,8 @@ var GeminiProvider = class {
 // src/providers/vertex.ts
 init_errors();
 init_gcloud();
-var DEFAULT_MODEL6 = "gemini-2.5-pro";
+init_catalog();
+var DEFAULT_MODEL6 = getCatalogDefaultModel("vertex");
 var DEFAULT_BASE_URL = "https://aiplatform.googleapis.com/v1";
 var DEFAULT_LOCATION = "global";
 var CONTEXT_WINDOWS6 = {
@@ -16896,11 +18126,16 @@ var VertexProvider = class {
     }
     yield { type: "done", stopReason };
   }
-  countTokens(text) {
-    return Math.ceil(text.length / 4);
+  countTokens(text2) {
+    return Math.ceil(text2.length / 4);
   }
   getContextWindow() {
-    return CONTEXT_WINDOWS6[this.config.model ?? DEFAULT_MODEL6] ?? 1048576;
+    const model2 = this.config.model ?? DEFAULT_MODEL6;
+    const catalogWindow = getCatalogContextWindow("vertex", model2, 0);
+    if (catalogWindow > 0) {
+      return catalogWindow;
+    }
+    return CONTEXT_WINDOWS6[model2] ?? 1048576;
   }
   async isAvailable() {
     try {
@@ -16917,8 +18152,8 @@ var VertexProvider = class {
       });
     }
   }
-  getModel(model) {
-    return model ?? this.config.model ?? DEFAULT_MODEL6;
+  getModel(model2) {
+    return model2 ?? this.config.model ?? DEFAULT_MODEL6;
   }
   getResolvedBaseUrl() {
     if (this.config.baseUrl && this.config.baseUrl.trim()) {
@@ -16929,9 +18164,9 @@ var VertexProvider = class {
     }
     return `https://${encodeURIComponent(this.location)}-aiplatform.googleapis.com/v1`;
   }
-  buildEndpoint(model, stream = false) {
+  buildEndpoint(model2, stream = false) {
     const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
-    return `${this.getResolvedBaseUrl()}/projects/${encodeURIComponent(this.project)}/locations/${encodeURIComponent(this.location)}/publishers/google/models/${encodeURIComponent(this.getModel(model))}:${action}`;
+    return `${this.getResolvedBaseUrl()}/projects/${encodeURIComponent(this.project)}/locations/${encodeURIComponent(this.location)}/publishers/google/models/${encodeURIComponent(this.getModel(model2))}:${action}`;
   }
   async getHeaders() {
     if (this.apiKey?.trim()) {
@@ -16959,8 +18194,8 @@ var VertexProvider = class {
     const systemMsg = messages.find((m) => m.role === "system");
     if (!systemMsg) return void 0;
     if (typeof systemMsg.content === "string") return systemMsg.content;
-    const text = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    return text || void 0;
+    const text2 = systemMsg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return text2 || void 0;
   }
   buildToolUseNameMap(messages) {
     const map = /* @__PURE__ */ new Map();
@@ -17143,21 +18378,21 @@ var VertexProvider = class {
       }
     }
   }
-  parseResponse(response, model) {
+  parseResponse(response, model2) {
     const candidate = response.candidates?.[0];
-    const text = (candidate?.content?.parts ?? []).filter((part) => part.text).map((part) => part.text).join("");
+    const text2 = (candidate?.content?.parts ?? []).filter((part) => part.text).map((part) => part.text).join("");
     return {
       id: `vertex-${Date.now()}`,
-      content: text,
+      content: text2,
       stopReason: this.mapFinishReason(candidate?.finishReason),
       usage: {
         inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
         outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model)
+      model: this.getModel(model2)
     };
   }
-  parseResponseWithTools(response, model) {
+  parseResponseWithTools(response, model2) {
     const candidate = response.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
     const toolCalls = [];
@@ -17185,7 +18420,7 @@ var VertexProvider = class {
         inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
         outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
       },
-      model: this.getModel(model),
+      model: this.getModel(model2),
       toolCalls
     };
   }
@@ -17214,6 +18449,10 @@ var VertexProvider = class {
   }
 };
 
+// src/providers/pricing.ts
+init_catalog();
+getCatalogModelPricingMap();
+
 // src/providers/circuit-breaker.ts
 init_errors();
 var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
@@ -17419,8 +18658,8 @@ var ResilientProvider = class {
   async *streamWithTools(messages, options) {
     yield* this.streamWithPolicy(() => this.provider.streamWithTools(messages, options));
   }
-  countTokens(text) {
-    return this.provider.countTokens(text);
+  countTokens(text2) {
+    return this.provider.countTokens(text2);
   }
   getContextWindow() {
     return this.provider.getContextWindow();
@@ -17506,13 +18745,16 @@ function createResilientProvider(provider, config) {
   return new ResilientProvider(provider, getDefaultResilienceConfig(provider.id));
 }
 
+// src/providers/runtime-capabilities.ts
+init_catalog();
+
 // src/providers/index.ts
 init_copilot();
 init_errors();
 init_env();
-function normalizeProviderModel(model) {
-  if (typeof model !== "string") return void 0;
-  const trimmed = model.trim();
+function normalizeProviderModel(model2) {
+  if (typeof model2 !== "string") return void 0;
+  const trimmed = model2.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function normalizeOptional(value) {
@@ -17721,9 +18963,9 @@ function createInitialState(config) {
 }
 async function loadExistingState(projectPath) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const statePath = `${projectPath}/.coco/state/project.json`;
-    const content = await fs39.readFile(statePath, "utf-8");
+    const content = await fs41.readFile(statePath, "utf-8");
     const data = JSON.parse(content);
     data.createdAt = new Date(data.createdAt);
     data.updatedAt = new Date(data.updatedAt);
@@ -17733,13 +18975,13 @@ async function loadExistingState(projectPath) {
   }
 }
 async function saveState(state) {
-  const fs39 = await import('fs/promises');
+  const fs41 = await import('fs/promises');
   const statePath = `${state.path}/.coco/state`;
-  await fs39.mkdir(statePath, { recursive: true });
+  await fs41.mkdir(statePath, { recursive: true });
   const filePath = `${statePath}/project.json`;
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
-  await fs39.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-  await fs39.rename(tmpPath, filePath);
+  await fs41.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs41.rename(tmpPath, filePath);
 }
 function getPhaseExecutor(phase) {
   switch (phase) {
@@ -17798,35 +19040,35 @@ async function createPhaseContext(config, state) {
   };
   const tools = {
     file: {
-      async read(path42) {
-        const fs39 = await import('fs/promises');
-        return fs39.readFile(path42, "utf-8");
+      async read(path44) {
+        const fs41 = await import('fs/promises');
+        return fs41.readFile(path44, "utf-8");
       },
-      async write(path42, content) {
-        const fs39 = await import('fs/promises');
+      async write(path44, content) {
+        const fs41 = await import('fs/promises');
         const nodePath = await import('path');
-        await fs39.mkdir(nodePath.dirname(path42), { recursive: true });
-        await fs39.writeFile(path42, content, "utf-8");
+        await fs41.mkdir(nodePath.dirname(path44), { recursive: true });
+        await fs41.writeFile(path44, content, "utf-8");
       },
-      async exists(path42) {
-        const fs39 = await import('fs/promises');
+      async exists(path44) {
+        const fs41 = await import('fs/promises');
         try {
-          await fs39.access(path42);
+          await fs41.access(path44);
           return true;
         } catch {
           return false;
         }
       },
       async glob(pattern) {
-        const { glob: glob17 } = await import('glob');
-        return glob17(pattern, { cwd: state.path });
+        const { glob: glob18 } = await import('glob');
+        return glob18(pattern, { cwd: state.path });
       }
     },
     bash: {
       async exec(command, options = {}) {
-        const { execa: execa11 } = await import('execa');
+        const { execa: execa12 } = await import('execa');
         try {
-          const result = await execa11(command, {
+          const result = await execa12(command, {
             shell: true,
             cwd: options.cwd || state.path,
             timeout: options.timeout,
@@ -17849,8 +19091,8 @@ async function createPhaseContext(config, state) {
     },
     git: {
       async status() {
-        const { execa: execa11 } = await import('execa');
-        const result = await execa11("git", ["status", "--porcelain", "-b"], { cwd: state.path });
+        const { execa: execa12 } = await import('execa');
+        const result = await execa12("git", ["status", "--porcelain", "-b"], { cwd: state.path });
         const lines = result.stdout.split("\n");
         const branchLine = lines[0] || "";
         const branch = branchLine.replace("## ", "").split("...")[0] || "main";
@@ -17863,24 +19105,24 @@ async function createPhaseContext(config, state) {
         };
       },
       async commit(message, files) {
-        const { execa: execa11 } = await import('execa');
+        const { execa: execa12 } = await import('execa');
         if (files && files.length > 0) {
-          await execa11("git", ["add", ...files], { cwd: state.path });
+          await execa12("git", ["add", ...files], { cwd: state.path });
         }
-        await execa11("git", ["commit", "-m", message], { cwd: state.path });
+        await execa12("git", ["commit", "-m", message], { cwd: state.path });
       },
       async push() {
-        const { execa: execa11 } = await import('execa');
-        await execa11("git", ["push"], { cwd: state.path });
+        const { execa: execa12 } = await import('execa');
+        await execa12("git", ["push"], { cwd: state.path });
       }
     },
     test: {
       async run(pattern) {
-        const { execa: execa11 } = await import('execa');
+        const { execa: execa12 } = await import('execa');
         try {
           const args = ["test", "--reporter=json"];
           if (pattern) args.push(pattern);
-          await execa11("pnpm", args, { cwd: state.path });
+          await execa12("pnpm", args, { cwd: state.path });
           return {
             passed: 0,
             failed: 0,
@@ -17960,9 +19202,9 @@ async function createSnapshot(state) {
 var MAX_CHECKPOINT_VERSIONS = 5;
 async function getCheckpointFiles(state, phase) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const checkpointDir = `${state.path}/.coco/checkpoints`;
-    const files = await fs39.readdir(checkpointDir);
+    const files = await fs41.readdir(checkpointDir);
     const phaseFiles = files.filter((f) => f.startsWith(`snapshot-pre-${phase}-`) && f.endsWith(".json")).sort((a, b) => {
       const tsA = parseInt(a.split("-").pop()?.replace(".json", "") ?? "0", 10);
       const tsB = parseInt(b.split("-").pop()?.replace(".json", "") ?? "0", 10);
@@ -17975,11 +19217,11 @@ async function getCheckpointFiles(state, phase) {
 }
 async function cleanupOldCheckpoints(state, phase) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const files = await getCheckpointFiles(state, phase);
     if (files.length > MAX_CHECKPOINT_VERSIONS) {
       const filesToDelete = files.slice(MAX_CHECKPOINT_VERSIONS);
-      await Promise.all(filesToDelete.map((f) => fs39.unlink(f).catch(() => {
+      await Promise.all(filesToDelete.map((f) => fs41.unlink(f).catch(() => {
       })));
     }
   } catch {
@@ -17987,13 +19229,13 @@ async function cleanupOldCheckpoints(state, phase) {
 }
 async function saveSnapshot(state, snapshotId) {
   try {
-    const fs39 = await import('fs/promises');
+    const fs41 = await import('fs/promises');
     const snapshotPath = `${state.path}/.coco/checkpoints/snapshot-${snapshotId}.json`;
     const snapshotDir = `${state.path}/.coco/checkpoints`;
-    await fs39.mkdir(snapshotDir, { recursive: true });
+    await fs41.mkdir(snapshotDir, { recursive: true });
     const createdAt = state.createdAt instanceof Date ? state.createdAt.toISOString() : String(state.createdAt);
     const updatedAt = state.updatedAt instanceof Date ? state.updatedAt.toISOString() : String(state.updatedAt);
-    await fs39.writeFile(
+    await fs41.writeFile(
       snapshotPath,
       JSON.stringify(
         {
@@ -18422,7 +19664,7 @@ Use list_dir or glob to find the correct path.`;
 }
 var readFileTool = defineTool({
   name: "read_file",
-  description: `Read the contents of a file.
+  description: `Read the full text content of a file at the given path and return it as a string. Use this when you need the actual source code, configuration values, or text content of a specific file you already know the path to. Do NOT use this to list files in a directory (use list_directory), to check if a file exists (use file_exists), or to search for files by name pattern (use find_files). Returns an error if the path does not exist or is not a readable text file.
 
 Examples:
 - Read config: { "path": "package.json" }
@@ -18480,7 +19722,7 @@ Examples:
 });
 var writeFileTool = defineTool({
   name: "write_file",
-  description: `Write content to a file, creating it if it doesn't exist.
+  description: `Write text content to a file, replacing it entirely if it already exists or creating it if it does not. Use this when you want to create a new file or fully replace an existing file's content. Do NOT use this to make a small change to an existing file (use edit_file instead, which performs a targeted find-and-replace without rewriting the whole file). Set createDirs: true to automatically create missing parent directories; otherwise the parent directory must already exist.
 
 Examples:
 - Create file: { "path": "src/utils.ts", "content": "export const foo = 1;" }
@@ -18541,7 +19783,7 @@ Examples:
 });
 var editFileTool = defineTool({
   name: "edit_file",
-  description: `Edit a file by replacing text (find and replace).
+  description: `Make a targeted text replacement inside an existing file by finding oldText and replacing it with newText. Use this for surgical edits to source code, configuration files, or documentation \u2014 it is much safer than rewriting the whole file with write_file because it only touches the exact bytes you specify. The oldText must match exactly (including whitespace and indentation); if it appears more than once in the file, use all: true to replace every occurrence or make oldText longer to be unique. Do NOT use this to create new files (use write_file) or to rename/move files (use move_path).
 
 Examples:
 - Single replace: { "path": "src/app.ts", "oldText": "TODO:", "newText": "DONE:" }
@@ -18625,7 +19867,7 @@ Hint: Use read_file first to verify the exact content.`
 });
 var globTool = defineTool({
   name: "glob",
-  description: `Find files matching a glob pattern.
+  description: `Find files whose paths match a glob pattern and return their relative paths as a list. Use this when you know the file extension or naming convention but not the exact path (e.g. find all TypeScript test files, all JSON configs). Do NOT use this to search inside file contents \u2014 use grep or search for that. Returns an empty list when nothing matches; does not throw an error for zero results. node_modules, .git, and dist directories are excluded by default.
 
 Examples:
 - All TypeScript: { "pattern": "**/*.ts" }
@@ -18667,7 +19909,7 @@ Examples:
 });
 var fileExistsTool = defineTool({
   name: "file_exists",
-  description: `Check if a file or directory exists.
+  description: `Check whether a path exists on disk and whether it is a file or directory. Use this before attempting to read or write a path when you are unsure it exists \u2014 it never throws, always returning { exists: false } for missing paths. Do NOT use this to read file contents (use read_file) or to list directory contents (use list_directory). Returns isFile and isDirectory flags so you can distinguish files from directories in a single call.
 
 Examples:
 - Check file: { "path": "package.json" } \u2192 { "exists": true, "isFile": true, "isDirectory": false }
@@ -18697,7 +19939,7 @@ Examples:
 });
 var listDirTool = defineTool({
   name: "list_dir",
-  description: `List contents of a directory.
+  description: `List the immediate entries (files and subdirectories) inside a directory and return their names, types, and sizes. Use this to understand what's in a folder before deciding which files to read. Do NOT use this to find files matching a pattern across the whole project (use glob) or to read file contents (use read_file). Returns an error if the path does not exist or is not a directory.
 
 Examples:
 - List src: { "path": "src" }
@@ -19130,16 +20372,11 @@ var SENSITIVE_ENV_PATTERNS = [
 ];
 var bashExecTool = defineTool({
   name: "bash_exec",
-  description: `Execute a bash/shell command in the user's shell environment.
+  description: `Execute a shell command and return its stdout, stderr, and exit code. Use this for running build scripts, test runners, linters, package managers, CLI tools, git commands, or any other shell operation. Runs in the user's shell environment with their full PATH and locally-configured credentials (kubeconfig, gcloud auth, AWS profiles, SSH keys) so never claim you cannot run a command due to missing credentials \u2014 always attempt and report the actual exit code. Do NOT use this to read or write files (use read_file / write_file / edit_file which are safer); prefer specific file tools for file operations.
 
 Runs with the user's full PATH and inherited environment \u2014 any tool installed
 on the user's machine is available: kubectl, gcloud, aws, docker, git, node,
-pnpm, and others. Credentials configured locally are inherited automatically:
-kubeconfig contexts, gcloud auth, AWS profiles, SSH keys, etc.
-
-IMPORTANT: never claim you cannot run a command because you lack credentials
-or access \u2014 the environment is the user's own shell. Always attempt; report
-failure only if the command actually returns a non-zero exit code.
+pnpm, and others.
 
 Examples:
 - List files:          { "command": "ls -la" }
@@ -19205,15 +20442,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -19408,7 +20645,7 @@ function getGit(cwd) {
 }
 var gitStatusTool = defineTool({
   name: "git_status",
-  description: `Get the current git repository status including branch, staged, modified, and untracked files.
+  description: `Return the current git repository state: branch name, staged files, modified files, and untracked files. Use this before committing to see what has changed, or to check which branch is active. Do NOT use this to see the content of changes (use git_diff), or to view history (use git_log). Returns isClean: true when the working tree is clean with nothing to commit.
 
 Examples:
 - Current dir: {} \u2192 { "branch": "main", "isClean": false, "modified": ["src/app.ts"] }
@@ -19442,7 +20679,7 @@ Examples:
 });
 var gitDiffTool = defineTool({
   name: "git_diff",
-  description: `Get git diff showing file changes.
+  description: `Show the unified diff of changes in the working tree or staging area. Use this to see exactly what lines changed in files before committing, or to review changes the user just made. Use staged: true to see only what has been staged (git add), or omit it to see all unstaged changes. Do NOT use this to see commit history (use git_log) or file status summary (use git_status).
 
 Examples:
 - All changes: {} \u2192 { "diff": "...", "filesChanged": 3, "insertions": 42, "deletions": 10 }
@@ -19479,7 +20716,7 @@ Examples:
 });
 var gitAddTool = defineTool({
   name: "git_add",
-  description: `Stage files for commit.
+  description: `Stage one or more files (or patterns) so they are included in the next git commit. Use this after making file edits to mark them ready for commit. Pass ["."] to stage all changes, or list specific file paths to stage selectively. Do NOT use this to commit (use git_commit after staging) or to view what is staged (use git_status or git_diff with staged: true).
 
 Examples:
 - Stage all: { "files": ["."] }
@@ -19505,7 +20742,7 @@ Examples:
 });
 var gitCommitTool = defineTool({
   name: "git_commit",
-  description: `Create a git commit with the staged changes.
+  description: `Create a git commit from whatever is currently staged (git add must run first). Use conventional commit format (feat/fix/docs/chore). Do NOT use this when nothing is staged \u2014 check git_status first; do NOT use this to stage files (use git_add) or to see what will be committed (use git_diff with staged: true).
 
 Examples:
 - Simple commit: { "message": "fix: resolve auth bug" }
@@ -19538,7 +20775,7 @@ Examples:
 });
 var gitLogTool = defineTool({
   name: "git_log",
-  description: `Get git commit history.
+  description: `Show git commit history with hashes, messages, authors, and dates. Use this to understand what changed recently, find the commit that introduced a bug, or check whether a feature was already merged. Do NOT use this to see the content of changes \u2014 use git_diff; do NOT use this to check current file state \u2014 use git_status.
 
 Examples:
 - Last 10 commits: {} (default)
@@ -19578,7 +20815,7 @@ Examples:
 });
 var gitBranchTool = defineTool({
   name: "git_branch",
-  description: `Manage git branches (list, create, delete).
+  description: `List all local branches, create a new branch from the current HEAD, or delete a branch. Use this to see available branches before checking out, or to create a feature branch. Do NOT use this to switch the active branch \u2014 use git_checkout; do NOT delete branches that have unmerged work.
 
 Examples:
 - List branches: {} \u2192 { "branches": ["main", "feature/x"], "current": "main" }
@@ -19622,7 +20859,7 @@ Examples:
 });
 var gitCheckoutTool = defineTool({
   name: "git_checkout",
-  description: `Switch branches or create and switch to a new branch.
+  description: `Switch the working directory to an existing branch, or create a new branch and switch to it in one step. Use this to move between branches or start a new feature branch. Do NOT use this with unsaved file edits (stage or stash first); do NOT use this to just list branches \u2014 use git_branch.
 
 Examples:
 - Switch branch: { "branch": "main" }
@@ -19652,7 +20889,7 @@ Examples:
 });
 var gitPushTool = defineTool({
   name: "git_push",
-  description: `Push commits to remote repository.
+  description: `Upload local commits to a remote repository. Use setUpstream: true the first time you push a new branch to create the tracking relationship. Do NOT use this on main/master without explicit user confirmation \u2014 it modifies shared history; do NOT push without first checking git_status to confirm all commits are clean.
 
 Examples:
 - Push current: {} \u2192 pushes to origin
@@ -19690,7 +20927,7 @@ Examples:
 });
 var gitPullTool = defineTool({
   name: "git_pull",
-  description: `Pull changes from remote repository.
+  description: `Fetch and integrate remote commits into the current branch. Use rebase: true to keep a linear history (preferred for feature branches). Do NOT use this when you have uncommitted local changes \u2014 stage or stash them first; if a merge conflict is reported, use read_file / edit_file to resolve then git_add and git_commit.
 
 Examples:
 - Pull current: {} \u2192 pulls from origin
@@ -20698,7 +21935,7 @@ Examples:
   }
 });
 async function findSourceFiles(cwd) {
-  const { glob: glob17 } = await import('glob');
+  const { glob: glob18 } = await import('glob');
   let isJava = false;
   try {
     await fs16__default.access(path17__default.join(cwd, "pom.xml"));
@@ -20716,12 +21953,12 @@ async function findSourceFiles(cwd) {
     }
   }
   if (isJava) {
-    return glob17("src/main/java/**/*.java", {
+    return glob18("src/main/java/**/*.java", {
       cwd,
       absolute: true
     });
   }
-  return glob17("src/**/*.{ts,js,tsx,jsx}", {
+  return glob18("src/**/*.{ts,js,tsx,jsx}", {
     cwd,
     absolute: true,
     ignore: ["**/*.test.*", "**/*.spec.*", "**/node_modules/**"]
@@ -20813,7 +22050,7 @@ var qualityTools = [runLinterTool, analyzeComplexityTool, calculateQualityTool];
 init_errors();
 var grepTool = defineTool({
   name: "grep",
-  description: `Search for text patterns in files using regex.
+  description: `Search for a regex pattern across all files in a directory and return matching lines with file paths and line numbers. Use this when you know a symbol name, string literal, or pattern and want to find where it appears in the codebase (function definitions, imports, error messages, config keys). Do NOT use this to find files by name \u2014 use glob for that. Do NOT use this when you already know the file path \u2014 use read_file directly. Searches are recursive by default; narrow with the include glob to restrict to specific file types.
 
 Examples:
 - Simple search: { "pattern": "TODO" }
@@ -20946,7 +22183,7 @@ Examples:
 });
 var findInFileTool = defineTool({
   name: "find_in_file",
-  description: `Search for a pattern in a single file.
+  description: `Search for a text or regex pattern inside a single known file and return matching line numbers and content. Use this when you already have the file path and want to quickly find which lines match (e.g. locate a function signature, find an import, or confirm a value exists). Do NOT use this to search across the whole project \u2014 use grep for that. Returns line numbers so you can navigate directly to the match.
 
 Examples:
 - Find text: { "file": "src/app.ts", "pattern": "export" }
@@ -21234,15 +22471,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21359,15 +22596,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21461,15 +22698,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21564,15 +22801,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21668,15 +22905,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21755,15 +22992,15 @@ ${message}
       let stdoutBuffer = "";
       let stderrBuffer = "";
       subprocess.stdout?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stdoutBuffer += text;
-        process.stdout.write(text);
+        const text2 = chunk.toString();
+        stdoutBuffer += text2;
+        process.stdout.write(text2);
         heartbeat.activity();
       });
       subprocess.stderr?.on("data", (chunk) => {
-        const text = chunk.toString();
-        stderrBuffer += text;
-        process.stderr.write(text);
+        const text2 = chunk.toString();
+        stderrBuffer += text2;
+        process.stderr.write(text2);
         heartbeat.activity();
       });
       const result = await subprocess;
@@ -21822,6 +23059,12 @@ z.object({
   "allowed-tools": z.union([z.string(), z.array(z.string())]).optional(),
   "argument-hint": z.string().optional(),
   compatibility: z.string().max(500).optional(),
+  triggers: z.union([z.string(), z.array(z.string())]).optional(),
+  risk: z.enum(["read-only", "write", "network", "destructive", "secrets-sensitive"]).optional(),
+  "supported-agents": z.union([
+    z.enum(["coco", "claude", "codex", "gemini", "opencode"]),
+    z.array(z.enum(["coco", "claude", "codex", "gemini", "opencode"]))
+  ]).optional(),
   model: z.string().optional(),
   context: z.enum(["fork", "agent", "inline"]).optional(),
   // Top-level tags/author (skills.sh style) — also accepted inside metadata
@@ -22447,7 +23690,7 @@ async function searchSerpApi(query, maxResults, timeout) {
 }
 var webSearchTool = defineTool({
   name: "web_search",
-  description: `Search the web for information, documentation, error solutions, and API references.
+  description: `Search the web using a natural-language query and return a list of result titles, URLs, and short excerpts. Use this when you need to find documentation, research an error message, discover API references, or learn about a library before you have a specific URL. Do NOT use this when you already have the URL \u2014 use web_fetch to read a known page directly. Returns result titles and URLs you can then fetch with web_fetch for full content.
 
 Examples:
 - Basic search: { "query": "typescript zod validation examples" }
@@ -22624,16 +23867,16 @@ function htmlToMarkdown(html) {
     const prefix = "#".repeat(i);
     const regex = new RegExp(`<h${i}[^>]*>([\\s\\S]*?)<\\/h${i}>`, "gi");
     md = md.replace(regex, (_, content) => {
-      const text = content.replace(/<[^>]*>/g, "").trim();
-      return text ? `
+      const text2 = content.replace(/<[^>]*>/g, "").trim();
+      return text2 ? `
 
-${prefix} ${text}
+${prefix} ${text2}
 
 ` : "";
     });
   }
-  md = md.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text) => {
-    const cleanText = text.replace(/<[^>]*>/g, "").trim();
+  md = md.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, text2) => {
+    const cleanText = text2.replace(/<[^>]*>/g, "").trim();
     if (!cleanText) return "";
     if (href.startsWith("#") || href.startsWith("javascript:")) return cleanText;
     return `[${cleanText}](${href})`;
@@ -22660,8 +23903,8 @@ ${decoded.trim()}
   });
   md = md.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_, items) => {
     return "\n" + items.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_2, item) => {
-      const text = item.replace(/<[^>]*>/g, "").trim();
-      return text ? `- ${text}
+      const text2 = item.replace(/<[^>]*>/g, "").trim();
+      return text2 ? `- ${text2}
 ` : "";
     }) + "\n";
   });
@@ -22669,29 +23912,29 @@ ${decoded.trim()}
     let counter = 0;
     return "\n" + items.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_2, item) => {
       counter++;
-      const text = item.replace(/<[^>]*>/g, "").trim();
-      return text ? `${counter}. ${text}
+      const text2 = item.replace(/<[^>]*>/g, "").trim();
+      return text2 ? `${counter}. ${text2}
 ` : "";
     }) + "\n";
   });
   md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
-    const text = content.replace(/<[^>]*>/g, "").trim();
-    return text ? "\n" + text.split("\n").map((line) => `> ${line.trim()}`).join("\n") + "\n" : "";
+    const text2 = content.replace(/<[^>]*>/g, "").trim();
+    return text2 ? "\n" + text2.split("\n").map((line) => `> ${line.trim()}`).join("\n") + "\n" : "";
   });
   md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, content) => {
-    const text = content.replace(/<[^>]*>/g, "").trim();
-    return text ? `
+    const text2 = content.replace(/<[^>]*>/g, "").trim();
+    return text2 ? `
 
-${text}
+${text2}
 
 ` : "";
   });
   md = md.replace(/<br\s*\/?>/gi, "\n");
   md = md.replace(
     /<(?:strong|b)[^>]*>([\s\S]*?)<\/(?:strong|b)>/gi,
-    (_, text) => `**${text.trim()}**`
+    (_, text2) => `**${text2.trim()}**`
   );
-  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, (_, text) => `*${text.trim()}*`);
+  md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, (_, text2) => `*${text2.trim()}*`);
   md = md.replace(/<hr\s*\/?>/gi, "\n---\n");
   md = md.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_, tableContent) => {
     const rows = [];
@@ -22728,7 +23971,7 @@ ${rows.join("\n")}
 }
 var webFetchTool = defineTool({
   name: "web_fetch",
-  description: `Fetch a URL and convert its content to clean markdown. Extracts main content, strips navigation/ads, and returns readable text.
+  description: `Fetch the content of a specific URL and return it as clean, readable markdown text. Use this when you already have the exact URL \u2014 for example a documentation page, a GitHub file, or an API response \u2014 and want to read its content. Do NOT use this to find information without a URL; use web_search instead to discover relevant URLs first. By default strips navigation menus, headers, and ads to return only the main content; set extractContent: false to get the raw HTML/text.
 
 Examples:
 - Fetch documentation: { "url": "https://docs.example.com/api" }
@@ -23373,9 +24616,9 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function fileExists2(path42) {
+async function fileExists2(path44) {
   try {
-    await access(path42);
+    await access(path44);
     return true;
   } catch {
     return false;
@@ -23465,7 +24708,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs39) => fs39.readFile(join(cwd, "package.json"), "utf-8")
+        (fs41) => fs41.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -24309,9 +25552,10 @@ Examples:
     exclude: z.array(z.string()).optional().describe("Additional patterns to exclude"),
     languages: z.array(z.enum(["typescript", "javascript", "python", "java", "go", "rust"])).optional().describe("Languages to parse (auto-detected if not specified)"),
     maxFiles: z.number().min(1).max(1e3).optional().default(DEFAULT_MAX_FILES).describe("Maximum files to process"),
-    depth: z.enum(["overview", "detailed"]).optional().default("overview").describe("Level of detail")
+    depth: z.enum(["overview", "detailed"]).optional().default("overview").describe("Level of detail"),
+    includeTests: z.boolean().optional().default(false).describe("Include test/spec files in the map")
   }),
-  async execute({ path: rootPath, include, exclude, languages, maxFiles, depth }) {
+  async execute({ path: rootPath, include, exclude, languages, maxFiles, depth, includeTests }) {
     const startTime = performance.now();
     const absPath = path27.resolve(rootPath);
     try {
@@ -24339,7 +25583,12 @@ Examples:
       const allExts = Object.values(LANGUAGE_EXTENSIONS).flat();
       pattern = `**/*{${allExts.join(",")}}`;
     }
-    const excludePatterns = [...DEFAULT_EXCLUDES, ...exclude ?? []];
+    const excludePatterns = [
+      ...DEFAULT_EXCLUDES.filter(
+        (pattern2) => includeTests ? !pattern2.includes("*.test.") && !pattern2.includes("*.spec.") : true
+      ),
+      ...exclude ?? []
+    ];
     const files = await glob14(pattern, {
       cwd: absPath,
       ignore: excludePatterns,
@@ -24439,8 +25688,7 @@ async function saveMemory(scope, memory) {
 }
 var createMemoryTool = defineTool({
   name: "create_memory",
-  description: `Save a memory (key-value pair) that persists between sessions.
-Use for storing project conventions, patterns, preferences, and learnings.
+  description: `Persist a named key-value fact that survives across sessions \u2014 use this for project conventions, patterns, user preferences, or discovered constraints you'll need later. If the key already exists the value is overwritten. Do NOT use this for temporary scratch data within a single session; do NOT use this to store file contents \u2014 use write_file for that.
 
 Examples:
 - Save convention: { "key": "naming-convention", "value": "Use camelCase for variables", "tags": ["style"] }
@@ -24497,7 +25745,7 @@ Examples:
 });
 var recallMemoryTool = defineTool({
   name: "recall_memory",
-  description: `Search and recall stored memories by key, tags, or free text query.
+  description: `Search previously saved memories by key substring, tags, or free-text value match. Use this at the start of a task to check if relevant conventions or patterns were already learned. Returns full memory content. Do NOT use this to list all memories (use list_memories) or to search file content (use grep).
 
 Examples:
 - By key substring: { "query": "naming" }
@@ -24552,7 +25800,7 @@ Examples:
 });
 var listMemoriesTool = defineTool({
   name: "list_memories",
-  description: `List all stored memories with optional filtering. Returns lightweight index entries.
+  description: `List stored memory keys and tags without loading full values \u2014 useful for browsing what has been saved before recalling specific entries. Do NOT use this to get memory content (use recall_memory for that).
 
 Examples:
 - List all: { "scope": "all" }
@@ -24838,10 +26086,10 @@ function chunkContent(content, chunkSize) {
   const chunks = [];
   for (let i = 0; i < lines.length; i += chunkSize) {
     const chunkLines = lines.slice(i, Math.min(i + chunkSize, lines.length));
-    const text = chunkLines.join("\n").trim();
-    if (text.length > 10) {
+    const text2 = chunkLines.join("\n").trim();
+    if (text2.length > 10) {
       chunks.push({
-        text,
+        text: text2,
         startLine: i + 1,
         endLine: Math.min(i + chunkSize, lines.length)
       });
@@ -24849,8 +26097,8 @@ function chunkContent(content, chunkSize) {
   }
   return chunks;
 }
-function simpleEmbedding(text) {
-  const words = text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
+function simpleEmbedding(text2) {
+  const words = text2.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
   const freq = /* @__PURE__ */ new Map();
   for (const word of words) {
     freq.set(word, (freq.get(word) ?? 0) + 1);
@@ -24876,7 +26124,7 @@ function simpleEmbedding(text) {
 }
 var embedFn = null;
 var usingFallbackEmbedding = false;
-async function getEmbedding(text) {
+async function getEmbedding(text2) {
   if (!embedFn) {
     try {
       const transformers = await import('@xenova/transformers');
@@ -24893,7 +26141,7 @@ async function getEmbedding(text) {
       usingFallbackEmbedding = true;
     }
   }
-  return embedFn(text);
+  return embedFn(text2);
 }
 async function loadIndex2(indexDir) {
   try {
@@ -25440,23 +26688,23 @@ Examples:
       const pdfData = await pdfParse.default(dataBuffer, {
         max: maxPages
       });
-      let text = pdfData.text;
+      let text2 = pdfData.text;
       let truncated = false;
       const totalPages = pdfData.numpages;
       if (pages) {
         const range = parsePageRange(pages, totalPages);
-        const pageTexts = text.split(/\f/);
+        const pageTexts = text2.split(/\f/);
         if (pageTexts.length > 1) {
           const selectedPages = pageTexts.slice(range.start - 1, range.end);
-          text = selectedPages.join("\n\n--- Page Break ---\n\n");
+          text2 = selectedPages.join("\n\n--- Page Break ---\n\n");
         }
       }
-      if (text.length > 5e5) {
-        text = text.slice(0, 5e5);
+      if (text2.length > 5e5) {
+        text2 = text2.slice(0, 5e5);
         truncated = true;
       }
       return {
-        text,
+        text: text2,
         pages: totalPages,
         metadata: {
           title: pdfData.info?.Title,
@@ -25555,14 +26803,14 @@ Examples:
     const mimeType = MIME_TYPES[ext] ?? "image/png";
     const selectedProvider = provider ?? "anthropic";
     let description;
-    let model;
+    let model2;
     try {
       if (selectedProvider === "anthropic") {
-        model = "claude-sonnet-4-20250514";
+        model2 = "claude-sonnet-4-20250514";
         const { default: Anthropic2 } = await import('@anthropic-ai/sdk');
         const client = new Anthropic2();
         const response = await client.messages.create({
-          model,
+          model: model2,
           max_tokens: 4096,
           messages: [
             {
@@ -25586,7 +26834,7 @@ Examples:
         });
         description = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n") || "No description generated";
       } else if (selectedProvider === "openai") {
-        model = "gpt-4o";
+        model2 = "gpt-4o";
         const { default: OpenAI3 } = await import('openai');
         const client = new OpenAI3();
         const openaiMessages = [
@@ -25607,13 +26855,13 @@ Examples:
           }
         ];
         const response = await client.chat.completions.create({
-          model,
+          model: model2,
           max_tokens: 4096,
           messages: openaiMessages
         });
         description = response.choices[0]?.message?.content ?? "No description generated";
       } else if (selectedProvider === "gemini") {
-        model = "gemini-2.0-flash";
+        model2 = "gemini-2.0-flash";
         const { GoogleGenAI: GoogleGenAI2 } = await import('@google/genai');
         const apiKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
         if (!apiKey) {
@@ -25624,7 +26872,7 @@ Examples:
         }
         const genAI = new GoogleGenAI2({ apiKey });
         const result = await genAI.models.generateContent({
-          model,
+          model: model2,
           contents: [
             {
               role: "user",
@@ -25667,7 +26915,7 @@ Examples:
     return {
       description,
       provider: selectedProvider,
-      model,
+      model: model2,
       duration: performance.now() - startTime,
       imageSize: imageBuffer.length,
       format: ext.slice(1)
@@ -25947,8 +27195,8 @@ async function analyzeFile(filePath, includeAst = false) {
   };
 }
 async function analyzeDirectory(dirPath) {
-  const { glob: glob17 } = await import('glob');
-  const files = await glob17("**/*.{ts,tsx,js,jsx}", {
+  const { glob: glob18 } = await import('glob');
+  const files = await glob18("**/*.{ts,tsx,js,jsx}", {
     cwd: dirPath,
     ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
     absolute: true
@@ -26020,6 +27268,329 @@ var analyzeDirectoryTool = defineTool({
   }
 });
 var codeAnalyzerTools = [analyzeFileTool, analyzeDirectoryTool];
+var SOURCE_GLOBS = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs"];
+var DEFAULT_EXCLUDES3 = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/*.d.ts"
+];
+async function commandAvailable(command) {
+  try {
+    await execa(command, ["--version"], { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getSourceFiles(root, maxFiles) {
+  const files = await glob(SOURCE_GLOBS, {
+    cwd: root,
+    absolute: false,
+    ignore: DEFAULT_EXCLUDES3,
+    nodir: true
+  });
+  return files.slice(0, maxFiles);
+}
+async function getFileSymbols(filePath) {
+  const absolutePath = path17__default.resolve(filePath);
+  const content = await fs16__default.readFile(absolutePath, "utf-8");
+  const language = detectLanguage3(absolutePath);
+  if (language !== "typescript" && language !== "javascript") {
+    return [];
+  }
+  return parseTypeScript(content).definitions.map((definition) => ({
+    file: filePath,
+    name: definition.name,
+    type: definition.type,
+    line: definition.line,
+    exported: definition.exported,
+    signature: definition.signature
+  }));
+}
+var lspStatusTool = defineTool({
+  name: "lsp_status",
+  description: "Check optional language-server availability. Use before LSP-style navigation when you need to know whether Coco is using static fallbacks.",
+  category: "search",
+  parameters: z.object({}),
+  async execute() {
+    return {
+      languageServers: [
+        {
+          name: "typescript-language-server",
+          available: await commandAvailable("typescript-language-server")
+        },
+        { name: "tsserver", available: await commandAvailable("tsserver") }
+      ],
+      fallbackMode: "static-analysis"
+    };
+  }
+});
+var lspDocumentSymbolsTool = defineTool({
+  name: "lsp_document_symbols",
+  description: "Return LSP-style document symbols for a TypeScript/JavaScript file using static analysis fallback.",
+  category: "search",
+  parameters: z.object({
+    file: z.string().describe("File path to inspect")
+  }),
+  async execute({ file }) {
+    return { symbols: await getFileSymbols(file) };
+  }
+});
+var lspWorkspaceSymbolsTool = defineTool({
+  name: "lsp_workspace_symbols",
+  description: "Find LSP-style workspace symbols by name across TypeScript/JavaScript files using static analysis fallback.",
+  category: "search",
+  parameters: z.object({
+    query: z.string().describe("Symbol name or substring to find"),
+    path: z.string().optional().describe("Workspace directory, defaults to cwd"),
+    maxFiles: z.number().optional().default(300),
+    maxResults: z.number().optional().default(100)
+  }),
+  async execute({ query, path: workspacePath, maxFiles = 300, maxResults = 100 }) {
+    const root = path17__default.resolve(workspacePath ?? process.cwd());
+    const files = await getSourceFiles(root, maxFiles);
+    const lowerQuery = query.toLowerCase();
+    const symbols = [];
+    for (const file of files) {
+      const fileSymbols = await getFileSymbols(path17__default.join(root, file));
+      for (const symbol of fileSymbols) {
+        if (!symbol.name.toLowerCase().includes(lowerQuery)) continue;
+        symbols.push({ ...symbol, file });
+        if (symbols.length >= maxResults) {
+          return { symbols, searchedFiles: files.length, truncated: true };
+        }
+      }
+    }
+    return { symbols, searchedFiles: files.length, truncated: false };
+  }
+});
+var lspDefinitionTool = defineTool({
+  name: "lsp_definition",
+  description: "Find the likely definition of a symbol using exported symbols first, then local definitions.",
+  category: "search",
+  parameters: z.object({
+    symbol: z.string().describe("Exact symbol name to locate"),
+    path: z.string().optional().describe("Workspace directory, defaults to cwd"),
+    maxFiles: z.number().optional().default(300)
+  }),
+  async execute({ symbol, path: workspacePath, maxFiles = 300 }) {
+    const root = path17__default.resolve(workspacePath ?? process.cwd());
+    const files = await getSourceFiles(root, maxFiles);
+    const candidates = [];
+    for (const file of files) {
+      const fileSymbols = await getFileSymbols(path17__default.join(root, file));
+      for (const candidate of fileSymbols) {
+        if (candidate.name !== symbol) continue;
+        candidates.push({ ...candidate, file });
+      }
+    }
+    const definition = candidates.find((candidate) => candidate.exported) ?? candidates[0];
+    return { definition, candidates };
+  }
+});
+var lspReferencesTool = defineTool({
+  name: "lsp_references",
+  description: "Find likely references to a symbol across TypeScript/JavaScript files using whole-word text search.",
+  category: "search",
+  parameters: z.object({
+    symbol: z.string().describe("Symbol name to find"),
+    path: z.string().optional().describe("Workspace directory, defaults to cwd"),
+    maxFiles: z.number().optional().default(300),
+    maxResults: z.number().optional().default(100)
+  }),
+  async execute({ symbol, path: workspacePath, maxFiles = 300, maxResults = 100 }) {
+    const root = path17__default.resolve(workspacePath ?? process.cwd());
+    const files = await getSourceFiles(root, maxFiles);
+    const pattern = new RegExp(`\\b${escapeRegExp(symbol)}\\b`);
+    const references = [];
+    for (const file of files) {
+      const absolutePath = path17__default.join(root, file);
+      const content = await fs16__default.readFile(absolutePath, "utf-8");
+      const lines = content.split("\n");
+      for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? "";
+        const match = pattern.exec(line);
+        if (!match) continue;
+        references.push({
+          file,
+          line: index + 1,
+          column: match.index + 1,
+          content: line.trim()
+        });
+        if (references.length >= maxResults) {
+          return { references, searchedFiles: files.length, truncated: true };
+        }
+      }
+    }
+    return { references, searchedFiles: files.length, truncated: false };
+  }
+});
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var lspTools = [
+  lspStatusTool,
+  lspDocumentSymbolsTool,
+  lspWorkspaceSymbolsTool,
+  lspDefinitionTool,
+  lspReferencesTool
+];
+var fs34 = await import('fs/promises');
+var path36 = await import('path');
+function cachePath(root) {
+  return path36.join(root, ".coco", "cache", "repo-index.json");
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_./:-]+/g, " ");
+}
+function queryTerms(query) {
+  return [
+    ...new Set(
+      normalizeText(query).split(/\s+/).filter((term) => term.length >= 2)
+    )
+  ];
+}
+function importTargetToPath(importTarget) {
+  return importTarget.replace(/^\.\//, "").replace(/\.(js|ts|tsx|jsx|mjs|cjs)$/, "");
+}
+function buildGraph(root, map) {
+  const inbound = /* @__PURE__ */ new Map();
+  const files = new Set(map.files.map((file) => file.path.replace(/\.[^.]+$/, "")));
+  for (const file of map.files) {
+    for (const importTarget of file.imports) {
+      const normalized = importTargetToPath(importTarget);
+      for (const candidate of files) {
+        if (candidate.endsWith(normalized) || normalized.endsWith(candidate)) {
+          inbound.set(candidate, (inbound.get(candidate) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  return {
+    root,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: map.files.map((file) => {
+      const withoutExt = file.path.replace(/\.[^.]+$/, "");
+      return {
+        ...file,
+        inboundImports: inbound.get(withoutExt) ?? 0,
+        testRelated: /(?:^|[/.-])(test|spec|__tests__)(?:[/.-]|$)/i.test(file.path)
+      };
+    }),
+    summary: map.summary
+  };
+}
+async function readCachedGraph(root) {
+  try {
+    const raw = await fs34.readFile(cachePath(root), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCachedGraph(root, graph) {
+  const file = cachePath(root);
+  await fs34.mkdir(path36.dirname(file), { recursive: true });
+  await fs34.writeFile(file, JSON.stringify(graph, null, 2) + "\n", "utf-8");
+}
+async function loadGraph(root, refresh) {
+  if (!refresh) {
+    const cached = await readCachedGraph(root);
+    if (cached) return cached;
+  }
+  const map = await codebaseMapTool.execute({
+    path: root,
+    maxFiles: 500,
+    depth: "detailed",
+    includeTests: true
+  });
+  const graph = buildGraph(root, map);
+  await writeCachedGraph(root, graph);
+  return graph;
+}
+function scoreFile(file, terms, mode, changedFiles) {
+  let score = 0;
+  const reasons = [];
+  const pathText = normalizeText(file.path);
+  const symbolText = normalizeText(file.definitions.map((def) => def.name).join(" "));
+  const importText = normalizeText([...file.imports, ...file.exports].join(" "));
+  for (const term of terms) {
+    if (pathText.includes(term)) {
+      score += 8;
+      reasons.push(`path:${term}`);
+    }
+    if (symbolText.includes(term)) {
+      score += 6;
+      reasons.push(`symbol:${term}`);
+    }
+    if (importText.includes(term)) {
+      score += 3;
+      reasons.push(`import/export:${term}`);
+    }
+  }
+  if (changedFiles.has(file.path)) {
+    score += 10;
+    reasons.push("changed-file");
+  }
+  if (file.inboundImports > 0) {
+    score += Math.min(6, file.inboundImports);
+    reasons.push(`centrality:${file.inboundImports}`);
+  }
+  if ((mode === "debug" || mode === "review") && file.testRelated) {
+    score += 4;
+    reasons.push("test-related");
+  }
+  if (file.exports.length > 0) {
+    score += 1;
+  }
+  return {
+    path: file.path,
+    score,
+    reasons: [...new Set(reasons)],
+    language: file.language,
+    lineCount: file.lineCount,
+    definitions: file.definitions.slice(0, 20),
+    imports: file.imports.slice(0, 20),
+    exports: file.exports.slice(0, 20)
+  };
+}
+async function getRepoContext(request) {
+  const root = path36.resolve(request.path ?? ".");
+  const budget = request.budget ?? 12;
+  const graph = await loadGraph(root, request.refresh ?? false);
+  const terms = queryTerms(request.query);
+  const changedFiles = new Set(request.changedFiles ?? []);
+  const items = graph.files.map((file) => scoreFile(file, terms, request.mode, changedFiles)).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, budget);
+  return {
+    graph: {
+      root: graph.root,
+      generatedAt: graph.generatedAt,
+      totalFiles: graph.summary.totalFiles,
+      totalDefinitions: graph.summary.totalDefinitions
+    },
+    query: request.query,
+    budget,
+    items
+  };
+}
+var repoContextTool = defineTool({
+  name: "repo_context",
+  description: "Return ranked, token-efficient repository context for a task using symbols, imports, tests, and centrality.",
+  category: "search",
+  parameters: z.object({
+    path: z.string().optional().default(".").describe("Repository root"),
+    query: z.string().min(1).describe("Task or search query to rank files against"),
+    budget: z.number().min(1).max(50).optional().default(12).describe("Maximum files to return"),
+    mode: z.enum(["ask", "plan", "build", "debug", "review", "architect"]).optional().describe("Agent mode to bias ranking"),
+    changedFiles: z.array(z.string()).optional().describe("Files already changed or selected"),
+    refresh: z.boolean().optional().default(false).describe("Refresh persistent repo index cache")
+  }),
+  execute: getRepoContext
+});
+var repoIntelligenceTools = [repoContextTool];
 var AgentTaskQueue = class {
   tasks = /* @__PURE__ */ new Map();
   completionOrder = [];
@@ -26328,15 +27899,15 @@ ${completed.map((r) => `- ${r.agentId}: Success`).join("\n")}`;
   }
 });
 var agentCoordinatorTools = [createAgentPlanTool, delegateTaskTool, aggregateResultsTool];
-var fs33 = await import('fs/promises');
+var fs35 = await import('fs/promises');
 var SuggestImprovementsSchema = z.object({
   filePath: z.string().describe("File to analyze for improvement suggestions"),
   context: z.string().optional().describe("Additional context about the code")
 });
 async function analyzeAndSuggest(filePath, _context) {
-  let rawContent = await fs33.readFile(filePath, "utf-8");
+  let rawContent = await fs35.readFile(filePath, "utf-8");
   if (typeof rawContent !== "string") {
-    const defaultReadFile = fs33.default?.readFile;
+    const defaultReadFile = fs35.default?.readFile;
     if (typeof defaultReadFile === "function") {
       rawContent = await defaultReadFile(filePath, "utf-8");
     }
@@ -26433,7 +28004,7 @@ async function analyzeAndSuggest(filePath, _context) {
     if (filePath.endsWith(".ts") && !filePath.includes("test") && !filePath.includes(".d.ts") && line.includes("export ")) {
       const testPath = filePath.replace(".ts", ".test.ts");
       try {
-        await fs33.access(testPath);
+        await fs35.access(testPath);
       } catch {
         suggestions.push({
           type: "testing",
@@ -26490,7 +28061,7 @@ var calculateCodeScoreTool = defineTool({
   async execute(input) {
     const { filePath } = input;
     const suggestions = await analyzeAndSuggest(filePath);
-    const content = await fs33.readFile(filePath, "utf-8");
+    const content = await fs35.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const nonEmptyLines = lines.filter((l) => l.trim()).length;
     let score = 100;
@@ -26524,8 +28095,8 @@ var calculateCodeScoreTool = defineTool({
   }
 });
 var smartSuggestionsTools = [suggestImprovementsTool, calculateCodeScoreTool];
-var fs34 = await import('fs/promises');
-var path35 = await import('path');
+var fs36 = await import('fs/promises');
+var path37 = await import('path');
 var ContextMemoryStore = class {
   items = /* @__PURE__ */ new Map();
   learnings = /* @__PURE__ */ new Map();
@@ -26537,7 +28108,7 @@ var ContextMemoryStore = class {
   }
   async load() {
     try {
-      const content = await fs34.readFile(this.storePath, "utf-8");
+      const content = await fs36.readFile(this.storePath, "utf-8");
       const data = JSON.parse(content);
       this.items = new Map(Object.entries(data.items || {}));
       this.learnings = new Map(Object.entries(data.learnings || {}));
@@ -26545,15 +28116,15 @@ var ContextMemoryStore = class {
     }
   }
   async save() {
-    const dir = path35.dirname(this.storePath);
-    await fs34.mkdir(dir, { recursive: true });
+    const dir = path37.dirname(this.storePath);
+    await fs36.mkdir(dir, { recursive: true });
     const data = {
       sessionId: this.sessionId,
       items: Object.fromEntries(this.items),
       learnings: Object.fromEntries(this.learnings),
       savedAt: Date.now()
     };
-    await fs34.writeFile(this.storePath, JSON.stringify(data, null, 2));
+    await fs36.writeFile(this.storePath, JSON.stringify(data, null, 2));
   }
   addContext(id, item) {
     this.items.set(id, item);
@@ -26718,11 +28289,11 @@ var contextEnhancerTools = [
   recordLearningTool,
   getLearnedPatternsTool
 ];
-var fs35 = await import('fs/promises');
-var path36 = await import('path');
+var fs37 = await import('fs/promises');
+var path38 = await import('path');
 async function discoverSkills(skillsDir) {
   try {
-    const files = await fs35.readdir(skillsDir);
+    const files = await fs37.readdir(skillsDir);
     return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
   } catch {
     return [];
@@ -26730,12 +28301,12 @@ async function discoverSkills(skillsDir) {
 }
 async function loadSkillMetadata(skillPath) {
   try {
-    const content = await fs35.readFile(skillPath, "utf-8");
+    const content = await fs37.readFile(skillPath, "utf-8");
     const nameMatch = content.match(/@name\s+(\S+)/);
     const descMatch = content.match(/@description\s+(.+)/);
     const versionMatch = content.match(/@version\s+(\S+)/);
     return {
-      name: nameMatch?.[1] || path36.basename(skillPath, path36.extname(skillPath)),
+      name: nameMatch?.[1] || path38.basename(skillPath, path38.extname(skillPath)),
       description: descMatch?.[1] || "No description",
       version: versionMatch?.[1] || "1.0.0",
       dependencies: []
@@ -26779,7 +28350,7 @@ var discoverSkillsTool = defineTool({
     const { skillsDir } = input;
     const skills = await discoverSkills(skillsDir);
     const metadata = await Promise.all(
-      skills.map((s) => loadSkillMetadata(path36.join(skillsDir, s)))
+      skills.map((s) => loadSkillMetadata(path38.join(skillsDir, s)))
     );
     return {
       skillsDir,
@@ -27074,7 +28645,7 @@ async function ghExec(args, cwd) {
 }
 var ghCheckAuthTool = defineTool({
   name: "gh_check_auth",
-  description: "Check if the GitHub CLI is installed and authenticated.",
+  description: "Verify the gh CLI is installed and the user is logged into GitHub. Call this before any other gh_ tool to confirm authentication is working. Returns the logged-in username if authenticated.",
   category: "git",
   parameters: z.object({
     cwd: z.string().optional()
@@ -27094,7 +28665,7 @@ var ghCheckAuthTool = defineTool({
 });
 var ghRepoInfoTool = defineTool({
   name: "gh_repo_info",
-  description: "Get GitHub repository information (name, default branch, URL).",
+  description: "Get the remote GitHub repository's name, owner, default branch, and URL from within the current git working directory. Use before creating PRs to confirm the target repo. Requires gh_check_auth to pass first.",
   category: "git",
   parameters: z.object({
     cwd: z.string().optional()
@@ -27116,7 +28687,7 @@ var ghRepoInfoTool = defineTool({
 });
 var ghPrCreateTool = defineTool({
   name: "gh_pr_create",
-  description: "Create a GitHub pull request.",
+  description: "Open a pull request on GitHub from the current branch. Requires commits to be pushed first (use git_push with setUpstream: true). Do NOT use this if a PR for this branch already exists \u2014 use gh_pr_list to check first. Use draft: true for work in progress.",
   category: "git",
   parameters: z.object({
     title: z.string().describe("PR title"),
@@ -27140,7 +28711,7 @@ var ghPrCreateTool = defineTool({
 });
 var ghPrMergeTool = defineTool({
   name: "gh_pr_merge",
-  description: "Merge a GitHub pull request.",
+  description: "Merge a pull request into its base branch. Use squash (default) for feature branches to keep history clean. Always confirm with gh_pr_checks first to ensure CI passed. Do NOT merge if anyFailed is true.",
   category: "git",
   parameters: z.object({
     number: z.number().describe("PR number"),
@@ -27161,7 +28732,7 @@ var ghPrMergeTool = defineTool({
 });
 var ghPrChecksTool = defineTool({
   name: "gh_pr_checks",
-  description: "Get CI check statuses for a pull request.",
+  description: "Poll the CI check results for a pull request \u2014 returns pass/fail/pending per check and convenience flags (allPassed, anyFailed). Call this after pushing to confirm CI is green before merging. Check anyPending to know if results are still arriving.",
   category: "git",
   parameters: z.object({
     number: z.number().describe("PR number"),
@@ -27195,7 +28766,7 @@ var ghPrChecksTool = defineTool({
 });
 var ghPrListTool = defineTool({
   name: "gh_pr_list",
-  description: "List pull requests, optionally filtered by head branch.",
+  description: "List open (or all) pull requests for this repository, optionally filtered to a specific branch. Use before gh_pr_create to ensure a PR for the current branch doesn't already exist. Returns PR number, title, URL, and state.",
   category: "git",
   parameters: z.object({
     head: z.string().optional().describe("Filter by head branch name"),
@@ -27212,7 +28783,7 @@ var ghPrListTool = defineTool({
 });
 var ghReleaseCreateTool = defineTool({
   name: "gh_release_create",
-  description: "Create a GitHub release with notes.",
+  description: "Publish a versioned GitHub release attached to a tag. The tag must already exist in the repo (push it with git_push first). Provide markdown release notes. Use prerelease: true for release candidates or beta builds.",
   category: "git",
   parameters: z.object({
     tag: z.string().describe("Tag name (e.g., v1.2.3)"),
@@ -27519,8 +29090,8 @@ var MCPRegistryImpl = class {
   /**
    * Ensure directory exists
    */
-  async ensureDir(path42) {
-    await mkdir(dirname(path42), { recursive: true });
+  async ensureDir(path44) {
+    await mkdir(dirname(path44), { recursive: true });
   }
 };
 
@@ -27536,6 +29107,8 @@ var MCPClientImpl = class {
     this.requestTimeout = requestTimeout;
     this.setupTransportHandlers();
   }
+  transport;
+  requestTimeout;
   requestId = 0;
   pendingRequests = /* @__PURE__ */ new Map();
   initialized = false;
@@ -27707,6 +29280,7 @@ var StdioTransport = class {
   constructor(config) {
     this.config = config;
   }
+  config;
   process = null;
   messageCallback = null;
   errorCallback = null;
@@ -28246,6 +29820,7 @@ var HTTPTransport = class {
     this.config.timeout = config.timeout ?? 6e4;
     this.config.retries = config.retries ?? 3;
   }
+  config;
   messageCallback = null;
   errorCallback = null;
   // Used to report transport errors to the client
@@ -29314,6 +30889,8 @@ function registerAllTools(registry) {
     ...databaseTools,
     ...astValidatorTools,
     ...codeAnalyzerTools,
+    ...lspTools,
+    ...repoIntelligenceTools,
     ...agentCoordinatorTools,
     ...smartSuggestionsTools,
     ...contextEnhancerTools,