tarsk 0.5.44 → 0.5.45

package/dist/index.js

@@ -60,11 +60,127 @@ var init_programs = __esm({
   }
 });
 
+// ../shared/dist/model-reasoning.js
+function isReasoningEffortLevel(value) {
+  return REASONING_EFFORT_LEVEL_SET.has(value);
+}
+function isModelReasoningSetting(value) {
+  return value === REASONING_EFFORT_OFF || isReasoningEffortLevel(value);
+}
+function normalizeModelSettings(settings) {
+  if (!settings) {
+    return { reasoningEffort: REASONING_EFFORT_OFF };
+  }
+  if (settings.reasoningEffort !== void 0) {
+    return { reasoningEffort: settings.reasoningEffort };
+  }
+  if (settings.reasoning !== void 0) {
+    return {
+      reasoningEffort: settings.reasoning ? "medium" : REASONING_EFFORT_OFF
+    };
+  }
+  return { reasoningEffort: REASONING_EFFORT_OFF };
+}
+function isReasoningEnabled(settings) {
+  return normalizeModelSettings(settings).reasoningEffort !== REASONING_EFFORT_OFF;
+}
+function getThinkingLevelFromSettings(settings) {
+  return normalizeModelSettings(settings).reasoningEffort ?? REASONING_EFFORT_OFF;
+}
+function clampReasoningEffort(effort, supportedEfforts) {
+  if (effort === REASONING_EFFORT_OFF || supportedEfforts.length === 0) {
+    return REASONING_EFFORT_OFF;
+  }
+  if (supportedEfforts.includes(effort)) {
+    return effort;
+  }
+  return supportedEfforts.includes("medium") ? "medium" : supportedEfforts[0] ?? REASONING_EFFORT_OFF;
+}
+var REASONING_EFFORT_OFF, REASONING_EFFORT_LEVELS, REASONING_EFFORT_LEVEL_SET;
+var init_model_reasoning = __esm({
+  "../shared/dist/model-reasoning.js"() {
+    "use strict";
+    REASONING_EFFORT_OFF = "off";
+    REASONING_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
+    REASONING_EFFORT_LEVEL_SET = new Set(REASONING_EFFORT_LEVELS);
+  }
+});
+
 // ../shared/dist/models.js
 var init_models = __esm({
   "../shared/dist/models.js"() {
     "use strict";
     init_programs();
+    init_model_reasoning();
+  }
+});
+
+// ../shared/dist/model-aliases.js
+function isModelAliasName(value) {
+  return MODEL_ALIAS_NAME_SET.has(value);
+}
+function normalizeProjectModelAliases(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("modelAliases must be an object");
+  }
+  const normalized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!isModelAliasName(key)) {
+      throw new Error(`Invalid model alias: ${key}`);
+    }
+    if (entry == null) {
+      continue;
+    }
+    if (typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Invalid model alias target for '${key}'`);
+    }
+    const model = typeof entry.model === "string" ? entry.model.trim() : "";
+    const provider = typeof entry.provider === "string" ? entry.provider.trim() : "";
+    if (!model || !provider) {
+      throw new Error(`Model alias '${key}' requires both model and provider`);
+    }
+    normalized[key] = { model, provider };
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function resolveModelAlias(model, aliases) {
+  if (!isModelAliasName(model)) {
+    return null;
+  }
+  return aliases?.[model] ?? null;
+}
+function getEnabledModelIdsForProvider(provider, enabledModelsByProvider) {
+  const providerSlug = provider.toLowerCase();
+  if (enabledModelsByProvider[providerSlug]) {
+    return enabledModelsByProvider[providerSlug];
+  }
+  const matchedEntry = Object.entries(enabledModelsByProvider).find(([key]) => key.toLowerCase() === providerSlug);
+  return matchedEntry?.[1] ?? [];
+}
+function isModelAliasTargetEnabled(target, enabledModelsByProvider) {
+  const enabledModelIds = getEnabledModelIdsForProvider(target.provider, enabledModelsByProvider);
+  return enabledModelIds.includes(target.model);
+}
+function validateProjectModelAliasesAgainstEnabled(aliases, enabledModelsByProvider) {
+  for (const aliasName of MODEL_ALIAS_NAMES) {
+    const target = aliases[aliasName];
+    if (!target) {
+      continue;
+    }
+    if (!isModelAliasTargetEnabled(target, enabledModelsByProvider)) {
+      throw new Error(`Model alias '${aliasName}' must reference an enabled model. '${target.provider}/${target.model}' is not enabled.`);
+    }
+  }
+}
+var MODEL_ALIAS_NAMES, MODEL_ALIAS_NAME_SET;
+var init_model_aliases = __esm({
+  "../shared/dist/model-aliases.js"() {
+    "use strict";
+    MODEL_ALIAS_NAMES = ["fast", "local", "cheap", "smart"];
+    MODEL_ALIAS_NAME_SET = new Set(MODEL_ALIAS_NAMES);
   }
 });
 
@@ -695,13 +811,14 @@ function resolveLocalProviderApiUrl(envValues) {
 function isLocalProvider(providerId) {
   return providerId.toLowerCase() === LOCAL_PROVIDER_ID;
 }
-var LOCAL_PROVIDER_ID, LOCAL_PROVIDER_NAME, LOCAL_PROVIDER_DEFAULT_API_URL, LOCAL_API_URL_ENV, LOCAL_API_KEY_ENV;
+var LOCAL_PROVIDER_ID, LOCAL_PROVIDER_NAME, LOCAL_PROVIDER_DEFAULT_API_URL, LOCAL_MODELS_FETCH_TIMEOUT_MS, LOCAL_API_URL_ENV, LOCAL_API_KEY_ENV;
 var init_providers = __esm({
   "../shared/dist/providers.js"() {
     "use strict";
     LOCAL_PROVIDER_ID = "local";
     LOCAL_PROVIDER_NAME = "Local";
     LOCAL_PROVIDER_DEFAULT_API_URL = "http://127.0.0.1:8000/v1";
+    LOCAL_MODELS_FETCH_TIMEOUT_MS = 5e3;
     LOCAL_API_URL_ENV = "LOCAL_API_URL";
     LOCAL_API_KEY_ENV = "LOCAL_API_KEY";
   }
@@ -867,11 +984,58 @@ var init_tmp_images = __esm({
   }
 });
 
+// ../shared/dist/git-status-dot.js
+function computeGitStatusDot(status) {
+  if (status.hasChanges)
+    return "changes";
+  if (status.hasUnpushedCommits && status.prExists)
+    return "update-pr";
+  if (status.prExists && status.prState === "OPEN" && !status.hasUnpushedCommits) {
+    return "open-pr";
+  }
+  return false;
+}
+var init_git_status_dot = __esm({
+  "../shared/dist/git-status-dot.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/skill-sources.js
+function isCustomSkillSourceId(sourceId) {
+  return sourceId.startsWith(CUSTOM_SKILL_SOURCE_ID_PREFIX);
+}
+function slugifySkillSourceTitle(title) {
+  return title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "source";
+}
+function createCustomSkillSourceId(title, existingIds) {
+  const slug = slugifySkillSourceTitle(title);
+  const base = `${CUSTOM_SKILL_SOURCE_ID_PREFIX}${slug}`;
+  const taken = new Set(existingIds);
+  if (!taken.has(base)) {
+    return base;
+  }
+  let suffix = 2;
+  while (taken.has(`${base}-${suffix}`)) {
+    suffix += 1;
+  }
+  return `${base}-${suffix}`;
+}
+var CUSTOM_SKILL_SOURCE_ID_PREFIX;
+var init_skill_sources = __esm({
+  "../shared/dist/skill-sources.js"() {
+    "use strict";
+    CUSTOM_SKILL_SOURCE_ID_PREFIX = "custom-";
+  }
+});
+
 // ../shared/dist/index.js
 var init_dist = __esm({
   "../shared/dist/index.js"() {
     "use strict";
     init_models();
+    init_model_aliases();
+    init_model_reasoning();
     init_commit_methods();
     init_package_managers();
     init_programs();
@@ -889,6 +1053,8 @@ var init_dist = __esm({
     init_project_env_vars();
     init_browser_tool();
     init_tmp_images();
+    init_git_status_dot();
+    init_skill_sources();
   }
 });
 
@@ -1966,6 +2132,14 @@ async function runMigrations(db) {
       tarskDebugLog("[db] Running migration: Adding allowedFetchDomains column to projects");
       await db.execute(`ALTER TABLE projects ADD COLUMN allowedFetchDomains TEXT`);
     }
+    const modelAliasesProjectsInfo = await db.execute(`PRAGMA table_info(projects)`);
+    const hasModelAliases = modelAliasesProjectsInfo.rows.some(
+      (col) => col.name === "modelAliases"
+    );
+    if (!hasModelAliases) {
+      tarskDebugLog("[db] Running migration: Adding modelAliases column to projects");
+      await db.execute(`ALTER TABLE projects ADD COLUMN modelAliases TEXT`);
+    }
     const projectScriptsExists = await db.execute(
       `SELECT name FROM sqlite_master WHERE type='table' AND name='project_scripts'`
     );
@@ -3496,9 +3670,9 @@ function createSimpleGrepTool(cwd, options) {
             const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT2);
             const formatPath = (filePath) => {
               if (isDirectory) {
-                const relative8 = path2.relative(searchPath, filePath);
-                if (relative8 && !relative8.startsWith("..")) {
-                  return relative8.replace(/\\/g, "/");
+                const relative9 = path2.relative(searchPath, filePath);
+                if (relative9 && !relative9.startsWith("..")) {
+                  return relative9.replace(/\\/g, "/");
                 }
               }
               return path2.basename(filePath);
@@ -3838,9 +4012,9 @@ function parseRipgrepOutput(stdout) {
   return stdout.trim().split("\n").map((line) => line.replace(/\r$/, "")).filter(Boolean);
 }
 function toRelativePath(cwd, filePath) {
-  const relative8 = path3.relative(cwd, filePath);
-  if (relative8 && !relative8.startsWith("..") && !path3.isAbsolute(relative8)) {
-    return relative8.replace(/\\/g, "/");
+  const relative9 = path3.relative(cwd, filePath);
+  if (relative9 && !relative9.startsWith("..") && !path3.isAbsolute(relative9)) {
+    return relative9.replace(/\\/g, "/");
   }
   return filePath.replace(/\\/g, "/");
 }
@@ -6282,6 +6456,7 @@ async function getCatalogProvider(providerId) {
 }
 
 // src/features/models/local-models.ts
+init_dist();
 function normalizeModelsBaseUrl(apiUrl) {
   const trimmed = apiUrl.trim().replace(/\/+$/, "");
   return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
@@ -6296,9 +6471,15 @@ async function fetchLocalModels(apiUrl, apiKey) {
   try {
     response = await fetch(`${baseUrl}/models`, {
       method: "GET",
-      headers
+      headers,
+      signal: AbortSignal.timeout(LOCAL_MODELS_FETCH_TIMEOUT_MS)
     });
   } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw new Error(
+        `Local API at ${baseUrl}/models did not respond within ${LOCAL_MODELS_FETCH_TIMEOUT_MS / 1e3} seconds`
+      );
+    }
     const detail = error instanceof Error ? error.message : "Unknown error";
     throw new Error(`Could not reach local API at ${baseUrl}/models: ${detail}`);
   }
@@ -6327,6 +6508,119 @@ async function fetchLocalModels(apiUrl, apiKey) {
   }));
 }
 
+// src/agent/agent.model-resolver.ts
+init_dist();
+import {
+  getModel,
+  getSupportedThinkingLevels
+} from "@earendil-works/pi-ai";
+var DEFAULT_HEADERS = {
+  "HTTP-Referer": "https://tarsk.io",
+  "X-Title": "Tarsk.io"
+};
+var PROVIDER_NAME_TO_PI = {
+  anthropic: "anthropic",
+  openai: "openai",
+  google: "google",
+  groq: "groq",
+  cerebras: "cerebras",
+  xai: "xai",
+  openrouter: "openrouter",
+  "github copilot": "github-copilot",
+  minimax: "minimax",
+  "kimi coding plan": "kimi-coding",
+  "hugging face": "huggingface",
+  codex: "openai-codex",
+  mistral: "mistral"
+};
+function determineApiType(providerName, apiUrl) {
+  const slug = providerName.toLowerCase();
+  if (isLocalProvider(slug)) {
+    return "openai-completions";
+  }
+  if (slug === "azure" || apiUrl.includes("openai.azure.com")) {
+    return "azure-openai-responses";
+  }
+  if (apiUrl.includes("/anthropic/")) return "anthropic-messages";
+  if (apiUrl.includes("api.anthropic.com")) return "anthropic-messages";
+  return "openai-completions";
+}
+var PI_REGISTRY_PROVIDERS_BY_API = {
+  "azure-openai-responses": "azure-openai-responses"
+};
+function getLocalModelResolveOptions(providerName, settings) {
+  if (!isLocalProvider(providerName)) {
+    return void 0;
+  }
+  const normalized = normalizeModelSettings(settings);
+  return {
+    reasoning: isReasoningEnabled(normalized)
+  };
+}
+function getSupportedReasoningEfforts(providerName, modelId, providerConfig) {
+  const resolved = resolveModel(providerName, modelId, providerConfig, { reasoning: true });
+  return getSupportedThinkingLevels(resolved).filter(
+    (level) => level !== "off"
+  );
+}
+function mergeModelHeaders(model) {
+  return { ...model, headers: { ...model.headers, ...DEFAULT_HEADERS } };
+}
+function tryGetRegistryModel(provider, modelId) {
+  const model = getModel(provider, modelId);
+  return model ?? void 0;
+}
+function applyReasoningOption(model, options) {
+  if (options?.reasoning === void 0) {
+    return model;
+  }
+  return { ...model, reasoning: options.reasoning };
+}
+function resolveModel(providerName, modelId, providerConfig, options) {
+  const piProvider = PROVIDER_NAME_TO_PI[providerName.toLowerCase()];
+  if (piProvider) {
+    const model = tryGetRegistryModel(piProvider, modelId);
+    if (model) {
+      return applyReasoningOption(mergeModelHeaders(model), options);
+    }
+  }
+  const baseUrl = providerConfig.api;
+  if (!baseUrl) {
+    throw new Error(`No API URL configured for provider: ${providerName}`);
+  }
+  const apiType = determineApiType(providerName, baseUrl);
+  const registryProvider = PI_REGISTRY_PROVIDERS_BY_API[apiType];
+  if (registryProvider) {
+    const model = tryGetRegistryModel(registryProvider, modelId);
+    if (model) {
+      return applyReasoningOption(
+        mergeModelHeaders({
+          ...model,
+          provider: providerName.toLowerCase(),
+          baseUrl
+        }),
+        options
+      );
+    }
+  }
+  return applyReasoningOption(
+    {
+      id: modelId,
+      name: modelId,
+      api: apiType,
+      provider: providerName.toLowerCase(),
+      baseUrl,
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128e3,
+      maxTokens: 16384,
+      headers: DEFAULT_HEADERS
+    },
+    options
+  );
+}
+
 // src/features/models/models.manager.ts
 var ModelManager = class {
   metadataManager;
@@ -6341,10 +6635,40 @@ var ModelManager = class {
    * Get available models for a provider.
    * Uses the remote catalog as the source for model lists, names, and pricing.
    */
+  async applyModelSettings(models, providerId) {
+    const settingsByModel = await this.metadataManager.getProviderModelSettings(providerId);
+    if (!isLocalProvider(providerId)) {
+      return models.map((model) => ({
+        ...model,
+        settings: normalizeModelSettings(settingsByModel[model.id])
+      }));
+    }
+    const envValues = await this.metadataManager.getProviderEnvValues();
+    const apiUrl = resolveLocalProviderApiUrl({
+      ...envValues,
+      [LOCAL_API_URL_ENV]: envValues[LOCAL_API_URL_ENV] ?? process.env[LOCAL_API_URL_ENV]
+    });
+    return models.map((model) => {
+      const supportedReasoningEfforts = getSupportedReasoningEfforts(providerId, model.id, {
+        api: apiUrl || LOCAL_PROVIDER_DEFAULT_API_URL
+      });
+      const normalized = normalizeModelSettings(settingsByModel[model.id]);
+      const reasoningEffort = clampReasoningEffort(
+        normalized.reasoningEffort ?? REASONING_EFFORT_OFF,
+        supportedReasoningEfforts
+      );
+      return {
+        ...model,
+        supportedReasoningEfforts,
+        settings: { reasoningEffort }
+      };
+    });
+  }
   async getAvailableModels(provider) {
     const providerId = provider.toLowerCase();
     if (isLocalProvider(providerId)) {
-      return this.getLocalAvailableModels();
+      const models = await this.getLocalAvailableModels();
+      return this.applyModelSettings(models, providerId);
     }
     const catalogProvider = await getCatalogProvider(providerId);
     if (!catalogProvider) {
@@ -6406,6 +6730,9 @@ var ModelManager = class {
       return [];
     }
   }
+  async getModelSettings(provider, modelId) {
+    return this.metadataManager.getModelSettings(provider, modelId);
+  }
   /**
    * Get a specific model by ID from a provider
    * @param provider - Provider name
@@ -6454,17 +6781,24 @@ var ModelManager = class {
   }
   async getAllEnabledImageModels() {
     const enabledByProvider = await this.metadataManager.getAllEnabledImageModels();
-    const result = {};
-    for (const provider of Object.keys(enabledByProvider)) {
-      try {
-        const availableModels = await this.getAvailableModels(provider);
-        const enabledIds = enabledByProvider[provider];
-        const models = availableModels.filter((model) => enabledIds.includes(model.id));
-        if (models.length > 0) {
-          result[provider] = models;
+    const providers = Object.keys(enabledByProvider);
+    const entries = await Promise.all(
+      providers.map(async (provider) => {
+        try {
+          const availableModels = await this.getAvailableModels(provider);
+          const enabledIds = enabledByProvider[provider];
+          const models = availableModels.filter((model) => enabledIds.includes(model.id));
+          return [provider, models];
+        } catch (error) {
+          console.error(`Failed to get enabled image models for ${provider}:`, error);
+          return [provider, []];
         }
-      } catch (error) {
-        console.error(`Failed to get enabled image models for ${provider}:`, error);
+      })
+    );
+    const result = {};
+    for (const [provider, models] of entries) {
+      if (models.length > 0) {
+        result[provider] = models;
       }
     }
     return result;
@@ -6475,15 +6809,22 @@ var ModelManager = class {
    */
   async getAllEnabledModels() {
     const enabledByProvider = await this.metadataManager.getAllEnabledModels();
-    const result = {};
-    for (const provider of Object.keys(enabledByProvider)) {
-      try {
-        const models = await this.getEnabledModels(provider);
-        if (models.length > 0) {
-          result[provider] = models;
+    const providers = Object.keys(enabledByProvider);
+    const entries = await Promise.all(
+      providers.map(async (provider) => {
+        try {
+          const models = await this.getEnabledModels(provider);
+          return [provider, models];
+        } catch (error) {
+          console.error(`Failed to get enabled models for ${provider}:`, error);
+          return [provider, []];
         }
-      } catch (error) {
-        console.error(`Failed to get enabled models for ${provider}:`, error);
+      })
+    );
+    const result = {};
+    for (const [provider, models] of entries) {
+      if (models.length > 0) {
+        result[provider] = models;
       }
     }
     return result;
@@ -8284,65 +8625,6 @@ function getDataDir() {
   return DATA_DIR;
 }
 
-// src/agent/agent.model-resolver.ts
-import { getModel } from "@earendil-works/pi-ai";
-var DEFAULT_HEADERS = {
-  "HTTP-Referer": "https://tarsk.io",
-  "X-Title": "Tarsk.io"
-};
-var PROVIDER_NAME_TO_PI = {
-  anthropic: "anthropic",
-  openai: "openai",
-  google: "google",
-  groq: "groq",
-  cerebras: "cerebras",
-  xai: "xai",
-  openrouter: "openrouter",
-  "github copilot": "github-copilot",
-  minimax: "minimax",
-  "kimi coding plan": "kimi-coding",
-  "hugging face": "huggingface",
-  codex: "openai-codex",
-  mistral: "mistral"
-};
-function determineApiType(providerName, apiUrl) {
-  const slug = providerName.toLowerCase();
-  if (slug === "azure" || apiUrl.includes("openai.azure.com")) {
-    return "azure-openai-responses";
-  }
-  if (apiUrl.includes("/anthropic/")) return "anthropic-messages";
-  if (apiUrl.includes("api.anthropic.com")) return "anthropic-messages";
-  return "openai-completions";
-}
-function resolveModel(providerName, modelId, providerConfig) {
-  const piProvider = PROVIDER_NAME_TO_PI[providerName.toLowerCase()];
-  if (piProvider) {
-    try {
-      const model = getModel(piProvider, modelId);
-      return { ...model, headers: { ...model.headers, ...DEFAULT_HEADERS } };
-    } catch {
-    }
-  }
-  const baseUrl = providerConfig.api;
-  if (!baseUrl) {
-    throw new Error(`No API URL configured for provider: ${providerName}`);
-  }
-  const apiType = determineApiType(providerName, baseUrl);
-  return {
-    id: modelId,
-    name: modelId,
-    api: apiType,
-    provider: providerName.toLowerCase(),
-    baseUrl,
-    reasoning: true,
-    input: ["text"],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 128e3,
-    maxTokens: 16384,
-    headers: DEFAULT_HEADERS
-  };
-}
-
 // src/features/git/git.utils.ts
 init_dist();
 import { completeSimple } from "@earendil-works/pi-ai";
@@ -10860,10 +11142,26 @@ async function* loadCodingToolsWithMcpStatus(cwd, options) {
 }
 
 // src/tools/agent-tool.ts
+init_dist();
 import { Type as Type21 } from "@sinclair/typebox";
 
+// src/features/projects/project-model-aliases.ts
+init_dist();
+async function validateProjectModelAliasesForSave(metadataManager, aliases) {
+  if (!aliases) {
+    return;
+  }
+  const enabledModelsByProvider = await metadataManager.getAllEnabledModels();
+  validateProjectModelAliasesAgainstEnabled(aliases, enabledModelsByProvider);
+}
+async function isProjectModelAliasTargetEnabled(metadataManager, target) {
+  const enabledModelsByProvider = await metadataManager.getAllEnabledModels();
+  return isModelAliasTargetEnabled(target, enabledModelsByProvider);
+}
+
 // src/agent/agent.subagent-executor.ts
 import { Agent } from "@earendil-works/pi-agent-core";
+init_dist();
 
 // src/agent/agent.event-transformer.ts
 init_dist();
@@ -11124,7 +11422,14 @@ async function executeSubagent(options) {
       `No API key found for subagent provider: ${providerName}. Set ${providerConfig.apiKeyEnv ?? "an API key"} in environment variables or configuration.`
     );
   }
-  const resolvedModel = resolveModel(providerName, model, providerConfig);
+  const localModelSettings = isLocalProvider(providerName) ? await metadataManager.getModelSettings(providerName, model) : {};
+  const thinkingLevel = getThinkingLevelFromSettings(localModelSettings);
+  const resolvedModel = resolveModel(
+    providerName,
+    model,
+    providerConfig,
+    getLocalModelResolveOptions(providerName, localModelSettings)
+  );
   console.log(
     `[subagent] Starting with model=${resolvedModel.id}, tools=${tools.map((t) => t.name).join(",")}`
   );
@@ -11132,7 +11437,8 @@ async function executeSubagent(options) {
     initialState: {
       systemPrompt,
       model: resolvedModel,
-      tools
+      tools,
+      thinkingLevel
     },
     streamFn: cachedStreamFn,
     getApiKey: async () => apiKey
@@ -11231,6 +11537,31 @@ function filterTools(baseTools, allowedToolNames) {
   );
   return baseTools.filter((t) => allowed.has(t.name));
 }
+function resolveSubagentModelSelection(agentDef, parentModel, parentProvider) {
+  if (agentDef?.model) {
+    return {
+      model: agentDef.model,
+      provider: agentDef.provider ?? parentProvider
+    };
+  }
+  return {
+    model: parentModel,
+    provider: parentProvider
+  };
+}
+async function resolveSubagentModelSelectionWithAliases(agentDef, parentModel, parentProvider, modelAliases, metadataManager) {
+  if (agentDef?.model && isModelAliasName(agentDef.model)) {
+    const aliasTarget = resolveModelAlias(agentDef.model, modelAliases);
+    if (aliasTarget && await isProjectModelAliasTargetEnabled(metadataManager, aliasTarget)) {
+      return aliasTarget;
+    }
+    return {
+      model: parentModel,
+      provider: parentProvider
+    };
+  }
+  return resolveSubagentModelSelection(agentDef, parentModel, parentProvider);
+}
 function createAgentTool(options) {
   const {
     agents,
@@ -11240,7 +11571,8 @@ function createAgentTool(options) {
     parentProvider,
     defaultSystemPrompt,
     onEvent,
-    signal
+    signal,
+    modelAliases
   } = options;
   return {
     name: "agent",
@@ -11263,8 +11595,13 @@ function createAgentTool(options) {
       }
       const label = description ?? agentName ?? "subagent";
       const systemPrompt = agentDef?.systemPrompt ?? defaultSystemPrompt;
-      const model = agentDef?.model ?? parentModel;
-      const provider = agentDef?.provider ?? parentProvider;
+      const { model, provider } = await resolveSubagentModelSelectionWithAliases(
+        agentDef,
+        parentModel,
+        parentProvider,
+        modelAliases,
+        metadataManager
+      );
       const subTools = filterTools(baseTools, agentDef?.tools);
       console.log(
         `[agent-tool] Spawning subagent '${label}' with model=${model}, tools=${subTools.map((t) => t.name).join(",")}`
@@ -12550,7 +12887,14 @@ var PiExecutorImpl = class {
         );
       }
       console.log(`[ai] API key source for ${providerName}: ${apiKeySource}`);
-      const resolvedModel = resolveModel(providerName, model, providerConfig);
+      const localModelSettings = isLocalProvider(providerName) ? await this.metadataManager.getModelSettings(providerName, model) : {};
+      const thinkingLevel = getThinkingLevelFromSettings(localModelSettings);
+      const resolvedModel = resolveModel(
+        providerName,
+        model,
+        providerConfig,
+        getLocalModelResolveOptions(providerName, localModelSettings)
+      );
       console.log("[ai] Resolved model:", {
         id: resolvedModel.id,
         api: resolvedModel.api,
@@ -12629,7 +12973,8 @@ var PiExecutorImpl = class {
           parentProvider: providerName,
           defaultSystemPrompt: systemPrompt,
           onEvent: (event) => eventQueue.push(event),
-          signal
+          signal,
+          modelAliases: context.modelAliases
         });
         tools.push(agentToolInstance);
       }
@@ -12639,7 +12984,8 @@ var PiExecutorImpl = class {
           systemPrompt,
           model: resolvedModel,
           tools,
-          messages: historyMessages
+          messages: historyMessages,
+          thinkingLevel
         },
         streamFn: cachedStreamFn,
         getApiKey: async () => apiKey,
@@ -14476,8 +14822,8 @@ async function insertProject(db, project) {
   try {
     await db.execute(
       `
-      INSERT INTO projects (id, name, gitUrl, path, createdAt, openWith, commands, setupScript, validationScript, runCommand, commitMethod, planPrompt, testPrompt, reviewPrompt, customSystemPrompt, useCustomSystemPrompt, allowAllCommands, allowedCommandPatterns, allowedFetchDomains)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, name, gitUrl, path, createdAt, openWith, commands, setupScript, validationScript, runCommand, commitMethod, planPrompt, testPrompt, reviewPrompt, customSystemPrompt, useCustomSystemPrompt, allowAllCommands, allowedCommandPatterns, allowedFetchDomains, modelAliases)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
       [
         project.id,
@@ -14498,7 +14844,8 @@ async function insertProject(db, project) {
         project.useCustomSystemPrompt ? 1 : 0,
         project.allowAllCommands === false ? 0 : 1,
         project.allowedCommandPatterns ? JSON.stringify(project.allowedCommandPatterns) : null,
-        project.allowedFetchDomains ? JSON.stringify(project.allowedFetchDomains) : null
+        project.allowedFetchDomains ? JSON.stringify(project.allowedFetchDomains) : null,
+        project.modelAliases ? JSON.stringify(project.modelAliases) : null
       ]
     );
   } catch (error) {
@@ -14582,6 +14929,10 @@ async function updateProject(db, id, updates) {
         updates.allowedFetchDomains.length > 0 ? JSON.stringify(updates.allowedFetchDomains) : null
       );
     }
+    if (updates.modelAliases !== void 0) {
+      fields.push("modelAliases = ?");
+      values.push(updates.modelAliases ? JSON.stringify(updates.modelAliases) : null);
+    }
     if (fields.length === 0) {
       return;
     }
@@ -14689,7 +15040,8 @@ function deserializeProjectWithThreads(row, threadIds) {
     useCustomSystemPrompt: Boolean(row.useCustomSystemPrompt),
     allowAllCommands: row.allowAllCommands === null ? true : Boolean(row.allowAllCommands),
     allowedCommandPatterns: row.allowedCommandPatterns ? JSON.parse(row.allowedCommandPatterns) : void 0,
-    allowedFetchDomains: row.allowedFetchDomains ? JSON.parse(row.allowedFetchDomains) : void 0
+    allowedFetchDomains: row.allowedFetchDomains ? JSON.parse(row.allowedFetchDomains) : void 0,
+    modelAliases: row.modelAliases ? JSON.parse(row.modelAliases) : void 0
   };
 }
 async function deserializeProject(db, row) {
@@ -14885,7 +15237,8 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
         await updateProject(dbInstance2, thread.projectId, {
           allowedFetchDomains: domains
         });
-      }
+      },
+      modelAliases: project?.modelAliases
     };
     console.log("[ChatRoute] Execution context:", {
       threadId,
@@ -16992,7 +17345,8 @@ async function computeContextBreakdown(threadId, conversationId, conversationMan
       parentProvider: thread.modelProvider ?? "",
       defaultSystemPrompt: promptSections.systemPrompt,
       onEvent: () => {
-      }
+      },
+      modelAliases: project?.modelAliases
     });
     tools.push(agentToolInstance);
   }
@@ -17404,6 +17758,7 @@ var MetadataManager = class {
         await setState(this.db, "selectedThreadId", state.selectedThreadId);
         await setState(this.db, "enabledModels", state.enabledModels);
         await setState(this.db, "enabledImageModels", state.enabledImageModels);
+        await setState(this.db, "modelSettings", state.modelSettings);
         await setState(this.db, "providerEnvValues", state.providerEnvValues);
         await setState(this.db, "onboardingCompleted", state.onboardingCompleted);
         const encryptedKeys = {};
@@ -17441,6 +17796,7 @@ var MetadataManager = class {
       const enabledImageModels = mergeEnabledModelsByProviderSlug(rawEnabledImageModels);
       const needsEnabledModelsMigration = enabledModelsNeedMigration(rawEnabledModels, enabledModels) || enabledModelsNeedMigration(rawEnabledImageModels, enabledImageModels);
       const providerEnvValues = allState.providerEnvValues || {};
+      const modelSettings = allState.modelSettings || {};
       const encryptedKeys = allState.providerKeys || {};
       const providerKeys = {};
       let needsMigration = false;
@@ -17482,7 +17838,8 @@ var MetadataManager = class {
         providerKeys,
         providerEnvValues,
         enabledModels,
-        enabledImageModels
+        enabledImageModels,
+        modelSettings
       };
     } catch (error) {
       throw new Error(`Failed to load state: ${String(error)}`);
@@ -17673,6 +18030,34 @@ var MetadataManager = class {
     }
     await this.saveState(state);
   }
+  async getModelSettings(provider, modelId) {
+    const providerSlug = normalizeProviderSlug(provider);
+    const state = await this.loadState();
+    return state.modelSettings[providerSlug]?.[modelId] ?? {};
+  }
+  async getProviderModelSettings(provider) {
+    const providerSlug = normalizeProviderSlug(provider);
+    const state = await this.loadState();
+    return state.modelSettings[providerSlug] ?? {};
+  }
+  async setModelSettings(provider, modelId, settings) {
+    const providerSlug = normalizeProviderSlug(provider);
+    const state = await this.loadState();
+    if (!state.modelSettings[providerSlug]) {
+      state.modelSettings[providerSlug] = {};
+    }
+    const nextSettings = { ...state.modelSettings[providerSlug][modelId], ...settings };
+    const hasSettings = Object.values(nextSettings).some((value) => value !== void 0);
+    if (hasSettings) {
+      state.modelSettings[providerSlug][modelId] = nextSettings;
+    } else {
+      delete state.modelSettings[providerSlug][modelId];
+      if (Object.keys(state.modelSettings[providerSlug]).length === 0) {
+        delete state.modelSettings[providerSlug];
+      }
+    }
+    await this.saveState(state);
+  }
   // ── Image model methods ─────────────────────────────────────────────────────
   async enableImageModel(provider, modelId) {
     const providerSlug = normalizeProviderSlug(provider);
@@ -17993,11 +18378,43 @@ async function handleGetModelInfo(c, modelManager) {
   }
 }
 
-// src/features/models/models.routes.ts
-function createModelRoutes(metadataManager) {
-  const router = new Hono6();
-  const modelManager = new ModelManager(metadataManager);
-  router.get("/", async (c) => {
+// src/features/models/models-model-settings.route.ts
+init_dist();
+async function handleModelSettings(c, metadataManager, modelManager) {
+  try {
+    const provider = c.req.param("provider");
+    const modelId = c.req.param("modelId");
+    if (!provider || !modelId) {
+      return c.json({ error: "provider and modelId are required" }, 400);
+    }
+    if (!isLocalProvider(provider)) {
+      return c.json({ error: "Model settings are only supported for the local provider" }, 400);
+    }
+    const body = await c.req.json();
+    if (body.reasoning !== void 0 && typeof body.reasoning !== "boolean") {
+      return c.json({ error: "reasoning must be a boolean" }, 400);
+    }
+    if (body.reasoningEffort !== void 0 && (typeof body.reasoningEffort !== "string" || !isModelReasoningSetting(body.reasoningEffort))) {
+      return c.json({ error: "reasoningEffort must be a supported reasoning level" }, 400);
+    }
+    const model = await modelManager.getModel(provider, modelId);
+    if (!model) {
+      return c.json({ error: `Model "${modelId}" not found in provider "${provider}"` }, 404);
+    }
+    await metadataManager.setModelSettings(provider, modelId, body);
+    const settings = await metadataManager.getModelSettings(provider, modelId);
+    return c.json({ provider, modelId, settings });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ error: message }, 500);
+  }
+}
+
+// src/features/models/models.routes.ts
+function createModelRoutes(metadataManager) {
+  const router = new Hono6();
+  const modelManager = new ModelManager(metadataManager);
+  router.get("/", async (c) => {
     return handleGetAvailableModels(c, modelManager);
   });
   router.get("/info", async (c) => {
@@ -18015,6 +18432,9 @@ function createModelRoutes(metadataManager) {
   router.post("/:provider/:modelId/disable", async (c) => {
     return handleModelDisable(c, modelManager);
   });
+  router.post("/:provider/:modelId/settings", async (c) => {
+    return handleModelSettings(c, metadataManager, modelManager);
+  });
   router.post("/:provider/refresh", async (c) => {
     return handleProviderRefresh(c, modelManager);
   });
@@ -18192,12 +18612,7 @@ async function handleCreateFolderProject(c, projectManager) {
 }
 
 // src/features/projects/projects-list.route.ts
-function computeGitStatusDot(status) {
-  if (status.hasChanges) return true;
-  if (status.commitsAheadOfDefault && !status.prExists) return true;
-  if (status.status === "Behind" || status.status === "Diverged") return true;
-  return false;
-}
+init_dist();
 async function handleListProjects(c, projectManager, threadManager, db) {
   try {
     const projects = await projectManager.listProjects();
@@ -18234,6 +18649,7 @@ async function handleListProjects(c, projectManager, threadManager, db) {
         useCustomSystemPrompt: project.useCustomSystemPrompt ?? false,
         allowAllCommands: project.allowAllCommands !== false,
         allowedCommandPatterns: project.allowedCommandPatterns ?? [],
+        modelAliases: project.modelAliases,
         threads: threads.map((thread) => {
           const cached = statusCache.get(thread.id);
           const gitStatusDot = cached ? computeGitStatusDot(cached) : false;
@@ -18499,7 +18915,7 @@ async function handleOpenProject(c, projectManager) {
 
 // src/features/projects/projects-update.route.ts
 init_dist();
-async function handleUpdateProject(c, projectManager) {
+async function handleUpdateProject(c, projectManager, metadataManager) {
   try {
     const projectId = c.req.param("id");
     const body = await c.req.json();
@@ -18517,7 +18933,8 @@ async function handleUpdateProject(c, projectManager) {
       customSystemPrompt,
       useCustomSystemPrompt,
       allowAllCommands,
-      allowedCommandPatterns
+      allowedCommandPatterns,
+      modelAliases
     } = body;
     if (!projectId) {
       return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
@@ -18581,6 +18998,17 @@ async function handleUpdateProject(c, projectManager) {
         allowedCommandPatterns
       });
     }
+    if (modelAliases !== void 0) {
+      let normalizedAliases;
+      try {
+        normalizedAliases = normalizeProjectModelAliases(modelAliases);
+        await validateProjectModelAliasesForSave(metadataManager, normalizedAliases);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResponse(c, ErrorCodes.INVALID_REQUEST, message, 400);
+      }
+      await projectManager.updateModelAliases(projectId, normalizedAliases);
+    }
     if (name !== void 0) {
       if (!name?.trim()) {
         return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project name is required", 400);
@@ -19436,7 +19864,7 @@ async function handleSyncProjectEnvVars(c, projectManager) {
 }
 
 // src/features/projects/projects.routes.ts
-function createProjectRoutes(projectManager, threadManager) {
+function createProjectRoutes(projectManager, threadManager, metadataManager) {
   const router = new Hono8();
   router.post("/", async (c) => {
     return handleCreateProject(c, projectManager);
@@ -19462,7 +19890,7 @@ function createProjectRoutes(projectManager, threadManager) {
     return handleOpenProject(c, projectManager);
   });
   router.put("/:id", async (c) => {
-    return handleUpdateProject(c, projectManager);
+    return handleUpdateProject(c, projectManager, metadataManager);
   });
   router.post("/:id/commands", async (c) => {
     return handleSaveCommand(c, projectManager);
@@ -21993,6 +22421,15 @@ ___CWD___%s
     }
     await this.metadataManager.saveProjects(projects);
   }
+  async updateModelAliases(projectId, modelAliases) {
+    const projects = await this.metadataManager.loadProjects();
+    const project = projects.find((p) => p.id === projectId);
+    if (!project) {
+      throw new Error(`Project not found: ${projectId}`);
+    }
+    project.modelAliases = modelAliases;
+    await this.metadataManager.saveProjects(projects);
+  }
   /**
    * Starts running a dev server process for a project
    * @param projectId - The project ID
@@ -23934,12 +24371,7 @@ async function handleCreateThread(c, threadManager, gitManager2) {
 }
 
 // src/features/threads/threads-list.route.ts
-function computeGitStatusDot2(status) {
-  if (status.hasChanges) return true;
-  if (status.commitsAheadOfDefault && !status.prExists) return true;
-  if (status.status === "Behind" || status.status === "Diverged") return true;
-  return false;
-}
+init_dist();
 async function handleListThreads(c, threadManager, db) {
   try {
     const projectId = c.req.query("projectId");
@@ -23961,7 +24393,7 @@ async function handleListThreads(c, threadManager, db) {
     );
     const threadsWithStatus = threads.map((thread) => {
       const cached = statusCache.get(thread.id);
-      const gitStatusDot = cached ? computeGitStatusDot2(cached) : false;
+      const gitStatusDot = cached ? computeGitStatusDot(cached) : false;
       return { ...thread, gitStatusDot };
     });
     return c.json(threadsWithStatus);
@@ -25197,20 +25629,43 @@ async function handleFixComments(c, threadManager) {
 
 // src/features/threads/threads-ai-files.route.ts
 init_dist();
-import { readFile as readFile16, writeFile as writeFile8, mkdir as mkdir9, access as access5, rm as rm7, stat as stat6 } from "fs/promises";
-import { join as join33 } from "path";
+import { readFile as readFile17, writeFile as writeFile8, mkdir as mkdir9, access as access5, rm as rm8, stat as stat6 } from "fs/promises";
+import { join as join34 } from "path";
 import { existsSync as existsSync19 } from "fs";
 
 // src/features/git/git-download-folder.ts
 import { mkdir as mkdir8, writeFile as writeFile7 } from "fs/promises";
 import { join as join32, dirname as dirname6 } from "path";
-async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
-  const { token, ref, excludeRelativePrefixes = [] } = options;
+
+// src/features/git/github-folder.ts
+function parseGithubRepoUrl(repoUrl) {
   const match = repoUrl.replace(/\.git$/, "").match(/github\.com\/([^/]+)\/([^/]+)/);
   if (!match) {
     throw new Error(`Invalid GitHub URL: ${repoUrl}`);
   }
   const [, owner, repo] = match;
+  return { owner, repo };
+}
+function normalizeFolderPrefix(srcPath) {
+  const trimmed = srcPath.replace(/^\/|\/$/g, "");
+  return trimmed.length > 0 ? `${trimmed}/` : "";
+}
+function filterFolderBlobPaths(tree, srcPath, excludeRelativePrefixes = []) {
+  const prefix = normalizeFolderPrefix(srcPath);
+  return tree.filter((entry) => {
+    if (entry.type !== "blob") {
+      return false;
+    }
+    if (prefix.length > 0) {
+      if (!entry.path.startsWith(prefix)) {
+        return false;
+      }
+    }
+    const relativePath = prefix.length > 0 ? entry.path.slice(prefix.length) : entry.path;
+    return !excludeRelativePrefixes.some((skipPrefix) => relativePath.startsWith(skipPrefix));
+  }).map((entry) => prefix.length > 0 ? entry.path.slice(prefix.length) : entry.path).sort((a, b) => a.localeCompare(b));
+}
+function buildGithubHeaders(token) {
   const headers = {
     Accept: "application/vnd.github+json",
     "X-GitHub-Api-Version": "2022-11-28"
@@ -25218,42 +25673,63 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   if (token) {
     headers["Authorization"] = `Bearer ${token}`;
   }
-  const refParam = ref ?? "HEAD";
+  return headers;
+}
+async function fetchGithubTree(owner, repo, refParam, token) {
   const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${refParam}?recursive=1`;
-  const treeRes = await fetch(treeUrl, { headers });
+  const treeRes = await fetch(treeUrl, { headers: buildGithubHeaders(token) });
   if (!treeRes.ok) {
     throw new Error(`GitHub API error ${treeRes.status}: ${await treeRes.text()}`);
   }
-  const tree = await treeRes.json();
+  return await treeRes.json();
+}
+async function listGithubFolderFiles(repoUrl, srcPath, options = {}) {
+  const { token, ref, excludeRelativePrefixes = [] } = options;
+  const { owner, repo } = parseGithubRepoUrl(repoUrl);
+  const refParam = ref ?? "HEAD";
+  const tree = await fetchGithubTree(owner, repo, refParam, token);
   if (tree.truncated) {
     console.warn(
       "Warning: the repository tree was truncated by GitHub. Large repos may be incomplete."
     );
   }
-  const prefix = srcPath.replace(/^\/|\/$/g, "") + "/";
-  const files = tree.tree.filter((entry) => {
-    if (entry.type !== "blob" || !entry.path.startsWith(prefix)) {
-      return false;
-    }
-    const relativePath = entry.path.slice(prefix.length);
-    return !excludeRelativePrefixes.some((skipPrefix) => relativePath.startsWith(skipPrefix));
-  });
+  const files = filterFolderBlobPaths(tree.tree, srcPath, excludeRelativePrefixes);
   if (files.length === 0) {
     throw new Error(`No files found at path "${srcPath}" in ${owner}/${repo}@${refParam}`);
   }
+  return { files, ref: refParam };
+}
+async function fetchGithubFolderFile(repoUrl, srcPath, relativePath, options = {}) {
+  const { token, ref } = options;
+  const { owner, repo } = parseGithubRepoUrl(repoUrl);
+  const refParam = ref ?? "HEAD";
+  const folderPrefix = normalizeFolderPrefix(srcPath);
+  const fullPath = folderPrefix.length > 0 ? `${folderPrefix}${relativePath}` : relativePath;
+  const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${refParam}/${fullPath}`;
+  const fileRes = await fetch(rawUrl, { headers: buildGithubHeaders(token) });
+  if (!fileRes.ok) {
+    throw new Error(`Failed to download ${fullPath}: HTTP ${fileRes.status}`);
+  }
+  let content = Buffer.from(await fileRes.arrayBuffer()).toString("utf8");
+  content = content.replace(/Claude/gi, "Tarsk");
+  return content;
+}
+
+// src/features/git/git-download-folder.ts
+async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
+  const { ref, excludeRelativePrefixes = [] } = options;
+  const { files, ref: refParam } = await listGithubFolderFiles(repoUrl, srcPath, options);
+  const { owner, repo } = parseGithubRepoUrl(repoUrl);
   console.log(`Downloading ${files.length} file(s) from ${owner}/${repo}/${srcPath} \u2192 ${destPath}`);
   await Promise.all(
-    files.map(async (file) => {
-      const relativePath = file.path.slice(prefix.length);
+    files.map(async (relativePath) => {
       const localPath = join32(destPath, relativePath);
       await mkdir8(dirname6(localPath), { recursive: true });
-      const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${refParam}/${file.path}`;
-      const fileRes = await fetch(rawUrl, { headers });
-      if (!fileRes.ok) {
-        throw new Error(`Failed to download ${file.path}: HTTP ${fileRes.status}`);
-      }
-      let content = Buffer.from(await fileRes.arrayBuffer()).toString("utf8");
-      content = content.replace(/Claude/gi, "Tarsk");
+      const content = await fetchGithubFolderFile(repoUrl, srcPath, relativePath, {
+        ...options,
+        ref: ref ?? refParam,
+        excludeRelativePrefixes
+      });
       await writeFile7(localPath, content, "utf8");
       console.log(`  \u2713 ${relativePath}`);
     })
@@ -25261,6 +25737,433 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   console.log("Done.");
 }
 
+// src/features/skills/skills.catalog-cache.ts
+import { cp, mkdtemp, readdir as readdir12, readFile as readFile16, rm as rm7 } from "fs/promises";
+import { join as join33, relative as relative8, sep } from "path";
+import { tmpdir as tmpdir3 } from "os";
+
+// src/features/git/git-clone-folder.ts
+init_utils();
+function normalizeGitCloneUrl(repoUrl) {
+  const trimmed = repoUrl.trim().replace(/\/$/, "");
+  return trimmed.endsWith(".git") ? trimmed : `${trimmed}.git`;
+}
+function runGit2(cwd, args2) {
+  const result = spawnSyncProcess("git", args2, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return {
+    ok: result.status === 0,
+    stderr: (typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() || "").trim()
+  };
+}
+async function cloneGithubRepoFolder(destPath, repoUrl, folderPath, options = {}) {
+  const ref = options.ref?.trim();
+  const cloneUrl = normalizeGitCloneUrl(repoUrl);
+  const trimmedFolderPath = folderPath.replace(/^\/|\/$/g, "");
+  const useSparseCheckout = trimmedFolderPath.length > 0;
+  const cloneArgs = [
+    "clone",
+    "--depth",
+    "1",
+    ...ref ? ["--branch", ref, "--single-branch"] : [],
+    ...useSparseCheckout ? ["--filter=blob:none", "--sparse"] : [],
+    cloneUrl,
+    destPath
+  ];
+  const cloneResult = runGit2(process.cwd(), cloneArgs);
+  if (!cloneResult.ok) {
+    const refLabel = ref ?? "default branch";
+    throw new Error(`Failed to clone ${repoUrl}@${refLabel}: ${cloneResult.stderr}`);
+  }
+  if (!useSparseCheckout) {
+    return;
+  }
+  const sparseResult = runGit2(destPath, ["sparse-checkout", "set", trimmedFolderPath]);
+  if (!sparseResult.ok) {
+    throw new Error(
+      `Failed to sparse-checkout "${trimmedFolderPath}" from ${repoUrl}: ${sparseResult.stderr}`
+    );
+  }
+}
+
+// src/features/git/github-tree-url.ts
+function parseGithubTreeUrl(url) {
+  const trimmed = url.trim().replace(/\/$/, "");
+  const treeMatch = trimmed.match(
+    /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(?:\/(.*))?$/
+  );
+  if (treeMatch) {
+    const [, owner, repoWithSuffix, ref, folderPath = ""] = treeMatch;
+    const repo = repoWithSuffix.replace(/\.git$/, "");
+    return {
+      owner,
+      repo,
+      repoUrl: `https://github.com/${owner}/${repo}`,
+      ref,
+      folderPath: folderPath.replace(/^\/|\/$/g, "")
+    };
+  }
+  const repoMatch = trimmed.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (repoMatch) {
+    const [, owner, repoWithSuffix] = repoMatch;
+    const repo = repoWithSuffix.replace(/\.git$/, "");
+    return {
+      owner,
+      repo,
+      repoUrl: `https://github.com/${owner}/${repo}`,
+      ref: "",
+      folderPath: ""
+    };
+  }
+  throw new Error(`Invalid GitHub tree URL: ${url}`);
+}
+
+// src/features/skills/skills.catalog-cache.ts
+init_dist();
+
+// src/features/skills/skills.custom-sources.ts
+init_dist();
+init_database();
+init_database_state();
+var STATE_KEY = "customSkillSources";
+function isValidSkillSource(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.title === "string" && typeof value.url === "string";
+}
+function parseCustomSkillSources(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.filter(isValidSkillSource).filter((source) => isCustomSkillSourceId(source.id)).sort((a, b) => a.title.localeCompare(b.title));
+}
+async function getCustomSkillSources() {
+  const db = await getDatabase();
+  const raw = await getState(db, STATE_KEY);
+  return parseCustomSkillSources(raw);
+}
+async function getCustomSkillSourceById(sourceId) {
+  const sources = await getCustomSkillSources();
+  return sources.find((source) => source.id === sourceId);
+}
+async function saveCustomSkillSource(source) {
+  if (!isCustomSkillSourceId(source.id)) {
+    throw new Error("Custom skill sources must use the custom- id prefix");
+  }
+  const db = await getDatabase();
+  const existing = await getCustomSkillSources();
+  const next = [...existing.filter((entry) => entry.id !== source.id), source].sort(
+    (a, b) => a.title.localeCompare(b.title)
+  );
+  await setState(db, STATE_KEY, next);
+  return source;
+}
+async function importCustomSkillSources(sources) {
+  const valid = sources.filter(isValidSkillSource).filter((source) => isCustomSkillSourceId(source.id));
+  if (valid.length === 0) {
+    return getCustomSkillSources();
+  }
+  const db = await getDatabase();
+  const existing = await getCustomSkillSources();
+  const byId = new Map(existing.map((source) => [source.id, source]));
+  for (const source of valid) {
+    byId.set(source.id, source);
+  }
+  const next = [...byId.values()].sort((a, b) => a.title.localeCompare(b.title));
+  await setState(db, STATE_KEY, next);
+  return next;
+}
+async function deleteCustomSkillSource(sourceId) {
+  if (!isCustomSkillSourceId(sourceId)) {
+    throw new Error("Only custom skill sources can be deleted");
+  }
+  const existing = await getCustomSkillSourceById(sourceId);
+  if (!existing) {
+    throw new Error("Unknown custom skill source");
+  }
+  const db = await getDatabase();
+  const sources = await getCustomSkillSources();
+  const next = sources.filter((entry) => entry.id !== sourceId);
+  await setState(db, STATE_KEY, next);
+  await clearCatalogClone(sourceId);
+}
+
+// src/features/skills/skills.sources.json
+var skills_sources_default = [
+  {
+    id: "openai-curated",
+    title: "OpenAI Curated",
+    url: "https://github.com/openai/skills/tree/main/skills/.curated"
+  },
+  {
+    id: "anthropic",
+    title: "Anthropic",
+    url: "https://github.com/anthropics/skills/tree/main/skills"
+  },
+  {
+    id: "matt-pocock-engineering",
+    title: "Engineering - Matt Pocock",
+    url: "https://github.com/mattpocock/skills/tree/main/skills/engineering"
+  },
+  {
+    id: "matt-pocock-productivity",
+    title: "Productivity -Matt Pocock",
+    url: "https://github.com/mattpocock/skills/tree/main/skills/productivity"
+  },
+  {
+    id: "cloudflare",
+    title: "Cloudflare",
+    url: "https://github.com/cloudflare/skills/tree/main/skills"
+  },
+  {
+    id: "vercel",
+    title: "Vercel",
+    url: "https://github.com/vercel-labs/agent-skills/tree/main/skills"
+  },
+  {
+    id: "microsoft",
+    title: "Microsoft",
+    url: "https://github.com/MicrosoftDocs/Agent-Skills/tree/main/skills"
+  },
+  {
+    id: "sentry",
+    title: "Sentry",
+    url: "https://github.com/getsentry/skills/tree/main/skills"
+  },
+  {
+    id: "firebase",
+    title: "Firebase",
+    url: "https://github.com/firebase/skills/tree/main/skills"
+  },
+  {
+    id: "flutter",
+    title: "Flutter",
+    url: "https://github.com/flutter/skills/tree/main/skills"
+  },
+  {
+    id: "angular",
+    title: "Angular",
+    url: "https://github.com/angular/skills/tree/main"
+  },
+  {
+    id: "firecrawl",
+    title: "Firecrawl",
+    url: "https://github.com/firecrawl/skills/tree/main/skills"
+  },
+  {
+    id: "redis",
+    title: "Redis",
+    url: "https://github.com/redis/agent-skills/tree/main/skills"
+  },
+  {
+    id: "corey-haines-marketing",
+    title: "Marketing - Corey Haines",
+    url: "https://github.com/coreyhaines31/marketingskills/tree/main/skills"
+  },
+  {
+    id: "dean-peters-product-management",
+    title: "Product Management - Dean Peters",
+    url: "https://github.com/deanpeters/Product-Manager-Skills/tree/main/skills"
+  },
+  {
+    id: "venice-ai",
+    title: "AI - Venice",
+    url: "https://github.com/veniceai/skills/tree/main/skills"
+  },
+  {
+    id: "superpowers",
+    title: "Development - Superpowers",
+    url: "https://github.com/obra/superpowers/tree/main/skills"
+  },
+  {
+    id: "cypress",
+    title: "Testing - Cypress",
+    url: "https://github.com/cypress-io/ai-toolkit/tree/main/skills"
+  },
+  {
+    id: "resend",
+    title: "Email - Resend",
+    url: "https://github.com/resend/resend-skills/tree/main/skills"
+  },
+  {
+    id: "n8n",
+    title: "Automation - n8n",
+    url: "https://github.com/czlonkowski/n8n-skills/tree/main/skills"
+  }
+];
+
+// src/features/skills/skills.catalog-cache.ts
+var catalogCloneCache = /* @__PURE__ */ new Map();
+var inFlightRefreshes = /* @__PURE__ */ new Map();
+function getBundledSkillSourceById(sourceId) {
+  return skills_sources_default.find((source) => source.id === sourceId);
+}
+async function resolveSkillSource(sourceId) {
+  const bundled = getBundledSkillSourceById(sourceId);
+  if (bundled) {
+    return bundled;
+  }
+  const custom = await getCustomSkillSourceById(sourceId);
+  if (custom) {
+    return custom;
+  }
+  throw new Error(`Unknown skill source: ${sourceId}`);
+}
+function normalizeSkillContent(content) {
+  return content.replace(/Claude/gi, "Tarsk");
+}
+async function listFilesRecursive(dir, rootDir = dir) {
+  const entries = await readdir12(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join33(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursive(fullPath, rootDir));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(relative8(rootDir, fullPath));
+    }
+  }
+  return files.sort((a, b) => a.localeCompare(b));
+}
+function resolveSkillRelativePath(skillDir, relativePath) {
+  const resolved = join33(skillDir, relativePath);
+  const normalizedSkillDir = skillDir.endsWith(sep) ? skillDir : `${skillDir}${sep}`;
+  if (resolved === skillDir || resolved.startsWith(normalizedSkillDir)) {
+    return resolved;
+  }
+  return null;
+}
+async function ensureCatalogClone(sourceId) {
+  const cached = catalogCloneCache.get(sourceId);
+  if (cached) {
+    return cached;
+  }
+  return refreshCatalogClone(sourceId);
+}
+async function getSkillDirEnsured(sourceId, skillId) {
+  const entry = await ensureCatalogClone(sourceId);
+  return join33(entry.scanDir, skillId);
+}
+async function cloneSourceToCache(sourceId, trustedUrl) {
+  let url;
+  if (trustedUrl !== void 0) {
+    if (!isCustomSkillSourceId(sourceId)) {
+      throw new Error(`Cannot override URL for skill source: ${sourceId}`);
+    }
+    url = trustedUrl;
+  } else {
+    url = (await resolveSkillSource(sourceId)).url;
+  }
+  const parsed = parseGithubTreeUrl(url);
+  const cloneDir = await mkdtemp(join33(tmpdir3(), "tarsk-skills-catalog-clone-"));
+  await cloneGithubRepoFolder(cloneDir, parsed.repoUrl, parsed.folderPath, {
+    ref: parsed.ref
+  });
+  const scanDir = parsed.folderPath ? join33(cloneDir, parsed.folderPath) : cloneDir;
+  const entry = {
+    sourceId,
+    cloneDir,
+    scanDir,
+    parsed,
+    fetchedAt: Date.now()
+  };
+  const previous = catalogCloneCache.get(sourceId);
+  catalogCloneCache.set(sourceId, entry);
+  if (previous) {
+    await rm7(previous.cloneDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  return entry;
+}
+async function refreshCatalogClone(sourceId, trustedUrl) {
+  const existing = inFlightRefreshes.get(sourceId);
+  if (existing) {
+    return existing;
+  }
+  const refreshPromise = cloneSourceToCache(sourceId, trustedUrl).finally(() => {
+    inFlightRefreshes.delete(sourceId);
+  });
+  inFlightRefreshes.set(sourceId, refreshPromise);
+  return refreshPromise;
+}
+function normalizeGithubRepoUrl(repoUrl) {
+  return repoUrl.trim().replace(/\/$/, "").replace(/\.git$/, "");
+}
+function resolveCatalogSkillFromGithubFolder(gitHubRepo, gitHubFolder) {
+  const normalizedRepo = normalizeGithubRepoUrl(gitHubRepo);
+  const normalizedFolder = gitHubFolder.replace(/^\/|\/$/g, "");
+  for (const source of skills_sources_default) {
+    const parsed = parseGithubTreeUrl(source.url);
+    if (normalizeGithubRepoUrl(parsed.repoUrl) !== normalizedRepo) {
+      continue;
+    }
+    const basePath = parsed.folderPath.replace(/^\/|\/$/g, "");
+    if (basePath.length > 0) {
+      const prefix = `${basePath}/`;
+      if (!normalizedFolder.startsWith(prefix)) {
+        continue;
+      }
+      const skillId2 = normalizedFolder.slice(prefix.length);
+      if (!skillId2 || skillId2.includes("/")) {
+        continue;
+      }
+      return { sourceId: source.id, skillId: skillId2, ref: parsed.ref };
+    }
+    const skillId = normalizedFolder.split("/")[0];
+    if (!skillId) {
+      continue;
+    }
+    return { sourceId: source.id, skillId, ref: parsed.ref };
+  }
+  return null;
+}
+async function resolveCatalogSkillFromGithubFolderEnsured(gitHubRepo, gitHubFolder) {
+  const resolved = resolveCatalogSkillFromGithubFolder(gitHubRepo, gitHubFolder);
+  if (!resolved) {
+    throw new Error(`No catalog source found for ${gitHubRepo}/${gitHubFolder}`);
+  }
+  await ensureCatalogClone(resolved.sourceId);
+  return resolved;
+}
+async function listCachedCatalogSkillFilesByGithubFolder(gitHubRepo, gitHubFolder) {
+  const resolved = await resolveCatalogSkillFromGithubFolderEnsured(gitHubRepo, gitHubFolder);
+  const files = await listCachedCatalogSkillFiles(resolved.sourceId, resolved.skillId);
+  return { files, ref: resolved.ref };
+}
+async function readCachedCatalogSkillFileByGithubFolder(gitHubRepo, gitHubFolder, relativePath) {
+  const resolved = await resolveCatalogSkillFromGithubFolderEnsured(gitHubRepo, gitHubFolder);
+  return readCachedCatalogSkillFile(resolved.sourceId, resolved.skillId, relativePath);
+}
+async function listCachedCatalogSkillFiles(sourceId, skillId) {
+  const skillDir = await getSkillDirEnsured(sourceId, skillId);
+  return listFilesRecursive(skillDir);
+}
+async function readCachedCatalogSkillFile(sourceId, skillId, relativePath) {
+  const skillDir = await getSkillDirEnsured(sourceId, skillId);
+  const absPath = resolveSkillRelativePath(skillDir, relativePath);
+  if (!absPath) {
+    throw new Error(`Invalid file path: ${relativePath}`);
+  }
+  const content = await readFile16(absPath, "utf8");
+  return normalizeSkillContent(content);
+}
+async function copyCachedCatalogSkillToDirectory(sourceId, skillId, destPath) {
+  const skillDir = await getSkillDirEnsured(sourceId, skillId);
+  await cp(skillDir, destPath, { recursive: true });
+}
+async function clearCatalogClone(sourceId) {
+  const entry = catalogCloneCache.get(sourceId);
+  if (!entry) {
+    return;
+  }
+  catalogCloneCache.delete(sourceId);
+  await rm7(entry.cloneDir, { recursive: true, force: true }).catch(() => {
+  });
+}
+
 // src/features/threads/threads-ai-files.route.ts
 async function handleGetThreadAIFiles(c, threadManager) {
   try {
@@ -25363,7 +26266,7 @@ Links to important documentation, tools, or references.
         400
       );
     }
-    const content = await readFile16(absPath, "utf-8");
+    const content = await readFile17(absPath, "utf-8");
     return c.json({ content, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -25402,7 +26305,7 @@ async function handleSaveThreadAIFile(c, threadManager) {
     if (!absPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
     }
-    const parentDir = join33(absPath, "..");
+    const parentDir = join34(absPath, "..");
     await mkdir9(parentDir, { recursive: true });
     await writeFile8(absPath, content, "utf-8");
     return c.json({ success: true, path: filePath });
@@ -25445,7 +26348,7 @@ async function handleDeleteThreadAIFile(c, threadManager) {
         404
       );
     }
-    await rm7(absPath, { recursive: true, force: true });
+    await rm8(absPath, { recursive: true, force: true });
     return c.json({ success: true, path: filePath });
   } catch (error) {
     return errorResponse(
@@ -25491,10 +26394,10 @@ async function handleCreateThreadAgent(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const agentRelPath = join33(".agents", "agents", name);
-    const agentAbsPath = join33(thread.path, agentRelPath);
-    const agentFileRelPath = join33(agentRelPath, "AGENT.md");
-    const agentFileAbsPath = join33(agentAbsPath, "AGENT.md");
+    const agentRelPath = join34(".agents", "agents", name);
+    const agentAbsPath = join34(thread.path, agentRelPath);
+    const agentFileRelPath = join34(agentRelPath, "AGENT.md");
+    const agentFileAbsPath = join34(agentAbsPath, "AGENT.md");
     if (existsSync19(agentAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Agent '${name}' already exists` } },
@@ -25561,10 +26464,10 @@ async function handleCreateThreadSkill(c, threadManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const skillRelPath = join33(".agents", "skills", name);
-    const skillAbsPath = join33(thread.path, skillRelPath);
-    const skillFileRelPath = join33(skillRelPath, "SKILL.md");
-    const skillFileAbsPath = join33(skillAbsPath, "SKILL.md");
+    const skillRelPath = join34(".agents", "skills", name);
+    const skillAbsPath = join34(thread.path, skillRelPath);
+    const skillFileRelPath = join34(skillRelPath, "SKILL.md");
+    const skillFileAbsPath = join34(skillAbsPath, "SKILL.md");
     if (existsSync19(skillAbsPath)) {
       return c.json(
         { error: { code: "CONFLICT", message: `Skill '${name}' already exists` } },
@@ -25607,7 +26510,7 @@ async function handleInstallGithubFolder(c, threadManager) {
     } catch {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
     }
-    const { gitHubRepo, gitHubFolder, destPath } = body;
+    const { gitHubRepo, gitHubFolder, destPath, gitHubRef } = body;
     if (!gitHubRepo || !gitHubFolder || !destPath) {
       return c.json(
         {
@@ -25627,7 +26530,9 @@ async function handleInstallGithubFolder(c, threadManager) {
     if (!absDestPath) {
       return c.json({ error: { code: "BAD_REQUEST", message: "Invalid destPath" } }, 400);
     }
-    await downloadGithubFolder(gitHubRepo, gitHubFolder, absDestPath);
+    await downloadGithubFolder(gitHubRepo, gitHubFolder, absDestPath, {
+      ref: gitHubRef
+    });
     return c.json({ success: true, path: destPath });
   } catch (error) {
     return errorResponse(
@@ -25639,6 +26544,50 @@ async function handleInstallGithubFolder(c, threadManager) {
     );
   }
 }
+async function handleInstallCatalogSkill(c, threadManager) {
+  try {
+    const threadId = c.req.param("id");
+    if (!threadId) {
+      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+    }
+    const { sourceId, skillId, destPath } = body;
+    if (!sourceId || !skillId || !destPath) {
+      return c.json(
+        {
+          error: {
+            code: "BAD_REQUEST",
+            message: "sourceId, skillId, and destPath are required"
+          }
+        },
+        400
+      );
+    }
+    const thread = await threadManager.getThread(threadId);
+    if (!thread) {
+      return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+    }
+    const absDestPath = validateFilePath(thread.path, destPath);
+    if (!absDestPath) {
+      return c.json({ error: { code: "BAD_REQUEST", message: "Invalid destPath" } }, 400);
+    }
+    await copyCachedCatalogSkillToDirectory(sourceId, skillId, absDestPath);
+    return c.json({ success: true, path: destPath });
+  } catch (error) {
+    return errorResponse(
+      c,
+      ErrorCodes.INTERNAL_ERROR,
+      "Failed to install catalog skill",
+      500,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
 
 // src/features/threads/threads-project-scripts.route.ts
 init_database();
@@ -25953,6 +26902,9 @@ function createThreadRoutes(threadManager, gitManager2, conversationManager) {
   router.post("/:id/ai-files/github-folder", async (c) => {
     return handleInstallGithubFolder(c, threadManager);
   });
+  router.post("/:id/ai-files/catalog-skill", async (c) => {
+    return handleInstallCatalogSkill(c, threadManager);
+  });
   return router;
 }
 
@@ -27916,7 +28868,7 @@ async function gitCheckoutBranchHandler(c, metadataManager) {
 import { unlinkSync } from "fs";
 import { resolve as resolve6 } from "path";
 init_utils();
-function runGit2(args2, cwd) {
+function runGit3(args2, cwd) {
   return new Promise((resolve8, reject) => {
     const proc = spawnProcess("git", args2, { cwd });
     let out = "";
@@ -27952,7 +28904,7 @@ async function gitRevertFileHandler(c, metadataManager) {
     } catch {
       return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
     }
-    const statusOutput = await runGit2(["status", "--porcelain", "--", filePath], gitRoot).catch(
+    const statusOutput = await runGit3(["status", "--porcelain", "--", filePath], gitRoot).catch(
       () => ""
     );
     const statusCode = statusOutput.trim().substring(0, 2);
@@ -27962,13 +28914,13 @@ async function gitRevertFileHandler(c, metadataManager) {
       } catch {
       }
     } else if (statusCode === "A ") {
-      await runGit2(["rm", "--cached", "--", filePath], gitRoot);
+      await runGit3(["rm", "--cached", "--", filePath], gitRoot);
       try {
         unlinkSync(resolve6(gitRoot, filePath));
       } catch {
       }
     } else {
-      await runGit2(["checkout", "HEAD", "--", filePath], gitRoot);
+      await runGit3(["checkout", "HEAD", "--", filePath], gitRoot);
     }
     return c.json({ success: true });
   } catch (error) {
@@ -28438,8 +29390,8 @@ function createUpdateRoutes(updater) {
 
 // src/features/mcp/mcp.routes.ts
 import { Hono as Hono15 } from "hono";
-import { readFile as readFile17, writeFile as writeFile9, mkdir as mkdir11, access as access6 } from "fs/promises";
-import { join as join34, dirname as dirname8 } from "path";
+import { readFile as readFile18, writeFile as writeFile9, mkdir as mkdir11, access as access6 } from "fs/promises";
+import { join as join35, dirname as dirname8 } from "path";
 
 // src/features/mcp/mcp.popular.json
 var mcp_popular_default = [
@@ -28561,10 +29513,10 @@ var mcp_popular_default = [
 var MCP_CONFIG_PATHS2 = [".agents/mcp.json", "mcp.json"];
 async function readMCPConfig(projectPath) {
   for (const configPath of MCP_CONFIG_PATHS2) {
-    const fullPath = join34(projectPath, configPath);
+    const fullPath = join35(projectPath, configPath);
     try {
       await access6(fullPath);
-      const content = await readFile17(fullPath, "utf-8");
+      const content = await readFile18(fullPath, "utf-8");
       const config = JSON.parse(content);
       return { config, filePath: fullPath };
     } catch {
@@ -28575,7 +29527,7 @@ async function readMCPConfig(projectPath) {
 }
 async function writeMCPConfig(projectPath, config) {
   const existing = await readMCPConfig(projectPath);
-  const targetPath = existing?.filePath ?? join34(projectPath, ".agents/mcp.json");
+  const targetPath = existing?.filePath ?? join35(projectPath, ".agents/mcp.json");
   await mkdir11(dirname8(targetPath), { recursive: true });
   await writeFile9(targetPath, JSON.stringify(config, null, 2), "utf-8");
 }
@@ -28778,11 +29730,328 @@ var skills_popular_default = [
   }
 ];
 
+// src/features/skills/skills.catalog.ts
+init_dist();
+import { readdir as readdir13, readFile as readFile19 } from "fs/promises";
+import { join as join36 } from "path";
+function getSkillSources() {
+  const sources = skills_sources_default;
+  return [...sources].sort((a, b) => a.title.localeCompare(b.title));
+}
+async function getAllSkillSources() {
+  const bundled = getSkillSources();
+  const custom = await getCustomSkillSources();
+  const bundledIds = new Set(bundled.map((source) => source.id));
+  const uniqueCustom = custom.filter((source) => !bundledIds.has(source.id));
+  return [...bundled, ...uniqueCustom].sort((a, b) => a.title.localeCompare(b.title));
+}
+async function scanDownloadedSkillCatalog(tmpDir, parsed, sourceId) {
+  const entries = await readdir13(tmpDir, { withFileTypes: true });
+  const catalogItems = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const skillMdPath = join36(tmpDir, entry.name, "SKILL.md");
+    let skillMdContent;
+    try {
+      skillMdContent = await readFile19(skillMdPath, "utf8");
+    } catch {
+      continue;
+    }
+    const { metadata } = parseSkillFrontmatter(skillMdContent);
+    const folderPath = parsed.folderPath ? `${parsed.folderPath}/${entry.name}` : entry.name;
+    catalogItems.push({
+      id: entry.name,
+      name: metadata.name ?? entry.name,
+      description: metadata.description ?? "",
+      sourceId,
+      gitHubRepo: parsed.repoUrl,
+      gitHubFolder: folderPath,
+      gitHubRef: parsed.ref
+    });
+  }
+  catalogItems.sort((a, b) => a.name.localeCompare(b.name));
+  return catalogItems;
+}
+async function fetchSkillCatalogFromSource(sourceId) {
+  const entry = await refreshCatalogClone(sourceId);
+  return scanDownloadedSkillCatalog(entry.scanDir, entry.parsed, sourceId);
+}
+async function verifySkillSource(title, url) {
+  const trimmedTitle = title.trim();
+  const trimmedUrl = url.trim();
+  if (!trimmedTitle) {
+    throw new Error("Title is required");
+  }
+  if (!trimmedUrl) {
+    throw new Error("URL is required");
+  }
+  parseGithubTreeUrl(trimmedUrl);
+  const bundledIds = skills_sources_default.map((source2) => source2.id);
+  const customIds = (await getCustomSkillSources()).map((source2) => source2.id);
+  const sourceId = createCustomSkillSourceId(trimmedTitle, [...bundledIds, ...customIds]);
+  const entry = await refreshCatalogClone(sourceId, trimmedUrl);
+  const skills = await scanDownloadedSkillCatalog(entry.scanDir, entry.parsed, sourceId);
+  if (skills.length === 0) {
+    await clearCatalogClone(sourceId);
+    throw new Error("No skills found at this URL");
+  }
+  const source = {
+    id: sourceId,
+    title: trimmedTitle,
+    url: trimmedUrl
+  };
+  await saveCustomSkillSource(source);
+  return {
+    source,
+    skillCount: skills.length
+  };
+}
+async function updateCustomSkillSource(sourceId, title, url) {
+  if (!isCustomSkillSourceId(sourceId)) {
+    throw new Error("Only custom skill sources can be updated");
+  }
+  const existing = await getCustomSkillSourceById(sourceId);
+  if (!existing) {
+    throw new Error("Unknown custom skill source");
+  }
+  const trimmedTitle = title.trim();
+  const trimmedUrl = url.trim();
+  if (!trimmedTitle) {
+    throw new Error("Title is required");
+  }
+  if (!trimmedUrl) {
+    throw new Error("URL is required");
+  }
+  parseGithubTreeUrl(trimmedUrl);
+  const entry = await refreshCatalogClone(sourceId, trimmedUrl);
+  const skills = await scanDownloadedSkillCatalog(entry.scanDir, entry.parsed, sourceId);
+  if (skills.length === 0) {
+    await clearCatalogClone(sourceId);
+    throw new Error("No skills found at this URL");
+  }
+  const source = {
+    id: sourceId,
+    title: trimmedTitle,
+    url: trimmedUrl
+  };
+  await saveCustomSkillSource(source);
+  return {
+    source,
+    skillCount: skills.length
+  };
+}
+
 // src/features/skills/skills.routes.ts
 function createSkillRoutes() {
   const router = new Hono16();
   router.get("/popular", (c) => {
-    return c.json({ skills: skills_popular_default });
+    const skills = [...skills_popular_default].sort((a, b) => a.name.localeCompare(b.name));
+    return c.json({ skills });
+  });
+  router.get("/sources", async (c) => {
+    return c.json({ sources: await getAllSkillSources() });
+  });
+  router.get("/catalog", async (c) => {
+    const sourceId = c.req.query("sourceId");
+    if (!sourceId) {
+      return c.json({ error: { code: "BAD_REQUEST", message: "sourceId is required" } }, 400);
+    }
+    try {
+      const skills = await fetchSkillCatalogFromSource(sourceId);
+      return c.json({ skills });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("Unknown skill source:") || message.startsWith("Invalid GitHub tree URL:")) {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.post("/sources/verify", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+    }
+    const title = body.title?.trim() ?? "";
+    const url = body.url?.trim() ?? "";
+    if (!title || !url) {
+      return c.json({ error: { code: "BAD_REQUEST", message: "title and url are required" } }, 400);
+    }
+    try {
+      const result = await verifySkillSource(title, url);
+      return c.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message === "Title is required" || message === "URL is required" || message === "No skills found at this URL" || message.startsWith("Invalid GitHub tree URL:")) {
+        return c.json({ error: { code: "BAD_REQUEST", message } }, 400);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.put("/sources/:sourceId", async (c) => {
+    const sourceId = c.req.param("sourceId");
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+    }
+    const title = body.title?.trim() ?? "";
+    const url = body.url?.trim() ?? "";
+    if (!title || !url) {
+      return c.json({ error: { code: "BAD_REQUEST", message: "title and url are required" } }, 400);
+    }
+    try {
+      const result = await updateCustomSkillSource(sourceId, title, url);
+      return c.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message === "Unknown custom skill source") {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      if (message === "Only custom skill sources can be updated" || message === "Title is required" || message === "URL is required" || message === "No skills found at this URL" || message.startsWith("Invalid GitHub tree URL:")) {
+        return c.json({ error: { code: "BAD_REQUEST", message } }, 400);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.delete("/sources/:sourceId", async (c) => {
+    const sourceId = c.req.param("sourceId");
+    try {
+      await deleteCustomSkillSource(sourceId);
+      return c.json({ success: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message === "Unknown custom skill source") {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      if (message === "Only custom skill sources can be deleted") {
+        return c.json({ error: { code: "BAD_REQUEST", message } }, 400);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.post("/sources/import", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+    }
+    if (!Array.isArray(body.sources)) {
+      return c.json({ error: { code: "BAD_REQUEST", message: "sources array is required" } }, 400);
+    }
+    try {
+      const sources = await importCustomSkillSources(
+        body.sources.filter(
+          (source) => typeof source?.id === "string" && typeof source?.title === "string" && typeof source?.url === "string"
+        )
+      );
+      return c.json({ sources });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.get("/catalog/files", async (c) => {
+    const sourceId = c.req.query("sourceId");
+    const skillId = c.req.query("skillId");
+    if (!sourceId || !skillId) {
+      return c.json(
+        { error: { code: "BAD_REQUEST", message: "sourceId and skillId are required" } },
+        400
+      );
+    }
+    try {
+      const files = await listCachedCatalogSkillFiles(sourceId, skillId);
+      return c.json({ files });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("Unknown skill source:")) {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.get("/catalog/file", async (c) => {
+    const sourceId = c.req.query("sourceId");
+    const skillId = c.req.query("skillId");
+    const relativePath = c.req.query("relativePath");
+    if (!sourceId || !skillId || !relativePath) {
+      return c.json(
+        {
+          error: {
+            code: "BAD_REQUEST",
+            message: "sourceId, skillId, and relativePath are required"
+          }
+        },
+        400
+      );
+    }
+    try {
+      const content = await readCachedCatalogSkillFile(sourceId, skillId, relativePath);
+      return c.json({ content, relativePath });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("Unknown skill source:") || message.startsWith("Invalid file path:")) {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.get("/github-folder/files", async (c) => {
+    const gitHubRepo = c.req.query("gitHubRepo");
+    const gitHubFolder = c.req.query("gitHubFolder");
+    if (!gitHubRepo || !gitHubFolder) {
+      return c.json(
+        { error: { code: "BAD_REQUEST", message: "gitHubRepo and gitHubFolder are required" } },
+        400
+      );
+    }
+    try {
+      const result = await listCachedCatalogSkillFilesByGithubFolder(gitHubRepo, gitHubFolder);
+      return c.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("No catalog source found")) {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
+  });
+  router.get("/github-folder/file", async (c) => {
+    const gitHubRepo = c.req.query("gitHubRepo");
+    const gitHubFolder = c.req.query("gitHubFolder");
+    const relativePath = c.req.query("relativePath");
+    if (!gitHubRepo || !gitHubFolder || !relativePath) {
+      return c.json(
+        {
+          error: {
+            code: "BAD_REQUEST",
+            message: "gitHubRepo, gitHubFolder, and relativePath are required"
+          }
+        },
+        400
+      );
+    }
+    try {
+      const content = await readCachedCatalogSkillFileByGithubFolder(
+        gitHubRepo,
+        gitHubFolder,
+        relativePath
+      );
+      return c.json({ content, relativePath });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("No catalog source found") || message.startsWith("Invalid file path:")) {
+        return c.json({ error: { code: "NOT_FOUND", message } }, 404);
+      }
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    }
   });
   return router;
 }
@@ -28992,7 +30261,7 @@ function getLocalNetworkAddresses() {
 
 // src/core/server-bind-mode-store.ts
 import { existsSync as existsSync25, mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync } from "fs";
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 
 // src/core/server-bind-mode.ts
 var DEFAULT_SERVER_BIND_MODE = "local";
@@ -29004,7 +30273,7 @@ function getServerBindHostname(mode) {
 }
 
 // src/core/server-bind-mode-store.ts
-var SERVER_BIND_MODE_FILE = join35(DATA_DIR, "server-bind-mode.json");
+var SERVER_BIND_MODE_FILE = join37(DATA_DIR, "server-bind-mode.json");
 function hasServerBindModeFile() {
   return existsSync25(SERVER_BIND_MODE_FILE);
 }
@@ -29358,7 +30627,7 @@ async function clipboardWriteImage(c) {
 
 // src/features/image/image-save.route.ts
 init_dist();
-import { join as join36 } from "path";
+import { join as join38 } from "path";
 var Utils5 = null;
 var utilsLoaded5 = false;
 async function loadUtils5() {
@@ -29396,7 +30665,7 @@ async function saveImage(c) {
       return c.json({ error: "imageUrl or imageData is required" }, 400);
     }
     const name = filename ?? `generated-image-${Date.now()}.png`;
-    const savePath = join36(Utils5.paths.downloads, name);
+    const savePath = join38(Utils5.paths.downloads, name);
     await Bun.write(savePath, data);
     return c.json({ success: true, path: savePath });
   } catch (error) {
@@ -29870,7 +31139,7 @@ async function startTarskServerInternal(options) {
       processingThreadIds: processingStateManager.getProcessingThreadIds()
     });
   });
-  app.route("/api/projects", createProjectRoutes(projectManager, threadManager));
+  app.route("/api/projects", createProjectRoutes(projectManager, threadManager, metadataManager));
   app.route("/api/projects", createRunRoutes(projectManager));
   app.route("/api/projects", createProjectTodosRoutes(metadataManager));
   app.route("/api/threads", createThreadRoutes(threadManager, gitManager2, conversationManager));