tarsk 0.5.43 → 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";
@@ -9080,53 +9362,128 @@ function stageAllChanges(gitRoot) {
     proc.on("error", reject);
   });
 }
-function commitChanges(gitRoot, message) {
-  return new Promise((resolve8, reject) => {
-    const proc = spawnProcess("git", ["commit", "-m", message], { cwd: gitRoot });
-    proc.on("close", (code) => {
-      if (code === 0) resolve8();
-      else reject(new Error("Failed to commit changes"));
-    });
-    proc.on("error", reject);
-  });
-}
-function pushToOrigin(gitRoot, currentBranch) {
+function getCommitCount(gitRoot) {
   return new Promise((resolve8, reject) => {
-    console.log(`[git-push] Executing: git push -u origin ${currentBranch}`);
-    const proc = spawnProcess("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
+    const proc = spawnProcess("git", ["rev-list", "--count", "HEAD"], { cwd: gitRoot });
+    let out = "";
     let err = "";
-    let _out = "";
     if (proc.stdout) {
       proc.stdout.on("data", (d) => {
-        _out += d.toString();
-        console.log(`[git-push] stdout: ${d.toString().trim()}`);
+        out += d.toString();
       });
     }
     if (proc.stderr) {
       proc.stderr.on("data", (d) => {
         err += d.toString();
-        console.log(`[git-push] stderr: ${d.toString().trim()}`);
       });
     }
     proc.on("close", (code) => {
-      console.log(`[git-push] git push exited with code: ${code}`);
       if (code === 0) {
-        console.log(`[git-push] \u2713 Push completed successfully`);
-        resolve8();
-      } else {
-        console.log(`[git-push] \u2717 Push failed with error: ${err || "Unknown error"}`);
-        reject(new Error(err || "Failed to push changes"));
+        resolve8(parseInt(out.trim(), 10) || 0);
+        return;
+      }
+      if (/unknown revision|ambiguous argument|does not have any commits yet|bad revision|needed a single revision/i.test(
+        err
+      )) {
+        resolve8(0);
+        return;
       }
+      reject(new Error(err.trim() || "Failed to count commits"));
     });
-    proc.on("error", (error) => {
-      console.log(
-        `[git-push] \u2717 Process error: ${error instanceof Error ? error.message : String(error)}`
-      );
-      reject(error);
+    proc.on("error", reject);
+  });
+}
+function checkBranchExists(gitRoot, branchName) {
+  return new Promise((resolve8) => {
+    const proc = spawnProcess(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
+      {
+        cwd: gitRoot
+      }
+    );
+    proc.on("close", (code) => {
+      resolve8(code === 0);
+    });
+    proc.on("error", () => {
+      resolve8(false);
     });
   });
 }
-function fetchFromOrigin(gitRoot) {
+function renameCurrentBranch(gitRoot, newBranchName) {
+  return new Promise((resolve8, reject) => {
+    const proc = spawnProcess("git", ["branch", "-m", newBranchName], {
+      cwd: gitRoot
+    });
+    let err = "";
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve8();
+      } else {
+        reject(new Error(err || `Failed to rename branch to "${newBranchName}"`));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+function commitChanges(gitRoot, message) {
+  return new Promise((resolve8, reject) => {
+    const proc = spawnProcess("git", ["commit", "-m", message], { cwd: gitRoot });
+    let err = "";
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code === 0) resolve8({ createdCommit: true });
+      else reject(new Error(err.trim() || "Failed to commit changes"));
+    });
+    proc.on("error", reject);
+  });
+}
+function pushToOrigin(gitRoot, currentBranch) {
+  return new Promise((resolve8, reject) => {
+    console.log(`[git-push] Executing: git push -u origin ${currentBranch}`);
+    const proc = spawnProcess("git", ["push", "-u", "origin", currentBranch], { cwd: gitRoot });
+    let err = "";
+    let _out = "";
+    if (proc.stdout) {
+      proc.stdout.on("data", (d) => {
+        _out += d.toString();
+        console.log(`[git-push] stdout: ${d.toString().trim()}`);
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+        console.log(`[git-push] stderr: ${d.toString().trim()}`);
+      });
+    }
+    proc.on("close", (code) => {
+      console.log(`[git-push] git push exited with code: ${code}`);
+      if (code === 0) {
+        console.log(`[git-push] \u2713 Push completed successfully`);
+        resolve8();
+      } else {
+        console.log(`[git-push] \u2717 Push failed with error: ${err || "Unknown error"}`);
+        reject(new Error(err || "Failed to push changes"));
+      }
+    });
+    proc.on("error", (error) => {
+      console.log(
+        `[git-push] \u2717 Process error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      reject(error);
+    });
+  });
+}
+function fetchFromOrigin(gitRoot) {
   return new Promise((resolve8, reject) => {
     const proc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
     let err = "";
@@ -10785,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();
@@ -11049,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(",")}`
   );
@@ -11057,7 +11437,8 @@ async function executeSubagent(options) {
     initialState: {
       systemPrompt,
       model: resolvedModel,
-      tools
+      tools,
+      thinkingLevel
     },
     streamFn: cachedStreamFn,
     getApiKey: async () => apiKey
@@ -11156,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,
@@ -11165,7 +11571,8 @@ function createAgentTool(options) {
     parentProvider,
     defaultSystemPrompt,
     onEvent,
-    signal
+    signal,
+    modelAliases
   } = options;
   return {
     name: "agent",
@@ -11188,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(",")}`
@@ -12475,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,
@@ -12554,7 +12973,8 @@ var PiExecutorImpl = class {
           parentProvider: providerName,
           defaultSystemPrompt: systemPrompt,
           onEvent: (event) => eventQueue.push(event),
-          signal
+          signal,
+          modelAliases: context.modelAliases
         });
         tools.push(agentToolInstance);
       }
@@ -12564,7 +12984,8 @@ var PiExecutorImpl = class {
           systemPrompt,
           model: resolvedModel,
           tools,
-          messages: historyMessages
+          messages: historyMessages,
+          thinkingLevel
         },
         streamFn: cachedStreamFn,
         getApiKey: async () => apiKey,
@@ -14401,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,
@@ -14423,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) {
@@ -14507,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;
     }
@@ -14614,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) {
@@ -14661,7 +15088,8 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
       attachments,
       planMode,
       ralphMode,
-      checkpointRef
+      checkpointRef,
+      conversationId: requestedConversationId
     } = body;
     let model = baseModel;
     if (provider && typeof provider === "string") {
@@ -14758,7 +15186,7 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
       }
       return streamAsyncGenerator(c, replayGenerator());
     }
-    let conversationId = thread.currentConversationId;
+    let conversationId = typeof requestedConversationId === "string" && requestedConversationId.length > 0 ? requestedConversationId : thread.currentConversationId;
     if (!conversationId) {
       conversationId = randomUUID8();
       const db2 = await getDatabase();
@@ -14809,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,
@@ -16916,7 +17345,8 @@ async function computeContextBreakdown(threadId, conversationId, conversationMan
       parentProvider: thread.modelProvider ?? "",
       defaultSystemPrompt: promptSections.systemPrompt,
       onEvent: () => {
-      }
+      },
+      modelAliases: project?.modelAliases
     });
     tools.push(agentToolInstance);
   }
@@ -17328,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 = {};
@@ -17365,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;
@@ -17406,7 +17838,8 @@ var MetadataManager = class {
         providerKeys,
         providerEnvValues,
         enabledModels,
-        enabledImageModels
+        enabledImageModels,
+        modelSettings
       };
     } catch (error) {
       throw new Error(`Failed to load state: ${String(error)}`);
@@ -17597,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);
@@ -17917,6 +18378,38 @@ async function handleGetModelInfo(c, modelManager) {
   }
 }
 
+// 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();
@@ -17939,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);
   });
@@ -18116,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();
@@ -18158,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;
@@ -18423,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();
@@ -18441,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);
@@ -18505,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);
@@ -19360,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);
@@ -19386,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);
@@ -19449,7 +19953,8 @@ import { rm as rm4 } from "fs/promises";
 // src/agent/agent.process-manager.ts
 init_utils();
 import { EventEmitter } from "events";
-init_tarsk_debug();
+
+// src/core/dev-server-url-detector.ts
 var URL_PATTERNS = [
   // http(s)://localhost:PORT
   /https?:\/\/localhost[:/](\d+)/i,
@@ -19462,6 +19967,24 @@ var URL_PATTERNS = [
   // Local address patterns like http://192.168...
   /https?:\/\/(192\.168\.\d+\.\d+):(\d+)/i
 ];
+function detectDevServerUrl(text) {
+  for (const pattern of URL_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      if (match[1] && !match[0].includes("://")) {
+        if (match[0].startsWith("127.0.0.1:")) {
+          return `http://${match[0]}`;
+        }
+        return `http://localhost:${match[1]}`;
+      }
+      return match[0];
+    }
+  }
+  return void 0;
+}
+
+// src/agent/agent.process-manager.ts
+init_tarsk_debug();
 var ProcessManager = class extends EventEmitter {
   processes = /* @__PURE__ */ new Map();
   detectedUrls = /* @__PURE__ */ new Map();
@@ -19537,7 +20060,7 @@ var ProcessManager = class extends EventEmitter {
         const text = data.toString();
         urlBuffer += text;
         if (!urlDetected) {
-          const detectedUrl = this.detectUrl(urlBuffer);
+          const detectedUrl = detectDevServerUrl(urlBuffer);
           if (detectedUrl) {
             urlDetected = true;
             this.detectedUrls.set(projectId, detectedUrl);
@@ -19551,7 +20074,7 @@ var ProcessManager = class extends EventEmitter {
         const text = data.toString();
         urlBuffer += text;
         if (!urlDetected) {
-          const detectedUrl = this.detectUrl(urlBuffer);
+          const detectedUrl = detectDevServerUrl(urlBuffer);
           if (detectedUrl) {
             urlDetected = true;
             this.detectedUrls.set(projectId, detectedUrl);
@@ -19642,23 +20165,6 @@ var ProcessManager = class extends EventEmitter {
   getDetectedUrl(projectId) {
     return this.detectedUrls.get(projectId);
   }
-  /**
-   * Detect URL from text output
-   * @param text - The text to search for URLs
-   * @returns The first detected URL or undefined
-   */
-  detectUrl(text) {
-    for (const pattern of URL_PATTERNS) {
-      const match = text.match(pattern);
-      if (match) {
-        if (match[1] && !match[0].includes("://")) {
-          return `http://localhost:${match[1]}`;
-        }
-        return match[0];
-      }
-    }
-    return void 0;
-  }
 };
 
 // src/features/projects/projects.creator.ts
@@ -20829,10 +21335,10 @@ async function loadUtils() {
   }
 }
 var ProjectCreator = class {
-  constructor(rootFolder, metadataManager, gitManager, processingStateManager, runCommandCallbacks) {
+  constructor(rootFolder, metadataManager, gitManager2, processingStateManager, runCommandCallbacks) {
     this.rootFolder = rootFolder;
     this.metadataManager = metadataManager;
-    this.gitManager = gitManager;
+    this.gitManager = gitManager2;
     this.processingStateManager = processingStateManager;
     this.runCommandCallbacks = runCommandCallbacks;
   }
@@ -21526,7 +22032,7 @@ var ProjectManagerImpl = class {
    * - 1.1 - WHEN a user provides a git URL to create a new Project, THE CLI SHALL clone the repository into a folder under the Root_Folder
    * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
    */
-  constructor(rootFolder, metadataManager, gitManager, processingStateManager) {
+  constructor(rootFolder, metadataManager, gitManager2, processingStateManager) {
     this.rootFolder = rootFolder;
     this.metadataManager = metadataManager;
     this.processManager = new ProcessManager();
@@ -21535,7 +22041,7 @@ var ProjectManagerImpl = class {
     this.projectCreator = new ProjectCreator(
       rootFolder,
       metadataManager,
-      gitManager,
+      gitManager2,
       processingStateManager,
       {
         suggestRunCommand: (id) => this.suggestRunCommand(id),
@@ -21915,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
@@ -23326,9 +23841,9 @@ var ThreadManagerImpl = class {
    * - 2.1 - WHEN a user creates a new Thread for a Project, THE CLI SHALL create a new clone of the Project's git repository
    * - 2.4 - THE System SHALL maintain a title for each Thread
    */
-  constructor(metadataManager, gitManager, processingStateManager, rootFolder = "") {
+  constructor(metadataManager, gitManager2, processingStateManager, rootFolder = "") {
     this.metadataManager = metadataManager;
-    this.gitManager = gitManager;
+    this.gitManager = gitManager2;
     this.processingStateManager = processingStateManager;
     this.rootFolder = rootFolder;
   }
@@ -23807,7 +24322,7 @@ function validateThreadName(name) {
 }
 
 // src/features/threads/threads-create.route.ts
-async function handleCreateThread(c, threadManager, gitManager) {
+async function handleCreateThread(c, threadManager, gitManager2) {
   try {
     const body = await c.req.json();
     const { projectId, title } = body;
@@ -23833,11 +24348,11 @@ async function handleCreateThread(c, threadManager, gitManager) {
         return errorResponse(c, ErrorCodes.INVALID_REQUEST, nameError, 400);
       }
       const existingThreads = await threadManager.listThreads(projectId);
-      const sanitizedNewName = gitManager.sanitizeBranchName(title);
-      const existingSanitized = existingThreads.map((t) => gitManager.sanitizeBranchName(t.title));
+      const sanitizedNewName = gitManager2.sanitizeBranchName(title);
+      const existingSanitized = existingThreads.map((t) => gitManager2.sanitizeBranchName(t.title));
       if (existingSanitized.includes(sanitizedNewName)) {
         let fallbackTitle = generateRandomThreadName();
-        while (existingSanitized.includes(gitManager.sanitizeBranchName(fallbackTitle))) {
+        while (existingSanitized.includes(gitManager2.sanitizeBranchName(fallbackTitle))) {
           fallbackTitle = generateRandomThreadName();
         }
         return streamAsyncGenerator(c, threadManager.createThread(projectId, fallbackTitle));
@@ -23856,12 +24371,7 @@ async function handleCreateThread(c, threadManager, gitManager) {
 }
 
 // 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");
@@ -23883,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);
@@ -24441,9 +24951,11 @@ async function handleGetThreadMessages(c, threadManager, conversationManager) {
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
-    const history = thread.currentConversationId ? await conversationManager.getConversationHistoryByConversationId(
+    const requestedConversationId = c.req.query("conversationId");
+    const targetConversationId = typeof requestedConversationId === "string" && requestedConversationId.length > 0 ? requestedConversationId : thread.currentConversationId;
+    const history = targetConversationId ? await conversationManager.getConversationHistoryByConversationId(
       threadId,
-      thread.currentConversationId
+      targetConversationId
     ) : await conversationManager.getConversationHistory(threadId);
     if (!history || history.messages.length === 0) {
       return c.json([]);
@@ -25117,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"
@@ -25138,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}`);
     })
@@ -25181,46 +25737,473 @@ async function downloadGithubFolder(repoUrl, srcPath, destPath, options = {}) {
   console.log("Done.");
 }
 
-// src/features/threads/threads-ai-files.route.ts
-async function handleGetThreadAIFiles(c, threadManager) {
-  try {
-    const threadId = c.req.param("id");
-    if (!threadId) {
-      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
-    }
-    if (!threadId) {
-      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
-    }
-    const thread = await threadManager.getThread(threadId);
-    if (!thread) {
-      return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-    }
-    const nodes = await buildAIFileTree(thread.path);
-    return c.json({ nodes });
-  } catch (error) {
-    return errorResponse(
-      c,
-      ErrorCodes.INTERNAL_ERROR,
-      "Failed to list AI files",
-      500,
-      error instanceof Error ? error.message : String(error)
+// 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}`
     );
   }
 }
-async function handleGetThreadAIFile(c, threadManager) {
-  try {
-    const threadId = c.req.param("id");
-    if (!threadId) {
-      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
-    }
-    const filePath = c.req.query("path");
-    if (!filePath) {
-      return c.json(
-        { error: { code: "BAD_REQUEST", message: "path query parameter is required" } },
-        400
-      );
-    }
-    const thread = await threadManager.getThread(threadId);
+
+// 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 {
+    const threadId = c.req.param("id");
+    if (!threadId) {
+      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+    }
+    if (!threadId) {
+      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+    }
+    const thread = await threadManager.getThread(threadId);
+    if (!thread) {
+      return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+    }
+    const nodes = await buildAIFileTree(thread.path);
+    return c.json({ nodes });
+  } catch (error) {
+    return errorResponse(
+      c,
+      ErrorCodes.INTERNAL_ERROR,
+      "Failed to list AI files",
+      500,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function handleGetThreadAIFile(c, threadManager) {
+  try {
+    const threadId = c.req.param("id");
+    if (!threadId) {
+      return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+    }
+    const filePath = c.req.query("path");
+    if (!filePath) {
+      return c.json(
+        { error: { code: "BAD_REQUEST", message: "path query parameter is required" } },
+        400
+      );
+    }
+    const thread = await threadManager.getThread(threadId);
     if (!thread) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
@@ -25283,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(
@@ -25322,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 });
@@ -25365,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(
@@ -25411,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` } },
@@ -25481,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` } },
@@ -25527,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(
         {
@@ -25547,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(
@@ -25559,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();
@@ -25568,17 +26597,22 @@ init_utils();
 import { spawnSync as spawnSync2 } from "child_process";
 var ScriptProcessManager = class {
   processes = /* @__PURE__ */ new Map();
+  threadIds = /* @__PURE__ */ new Map();
   /**
    * Run a script and stream its output
    * @param key - Unique key for this script (e.g. "projectId:scriptName")
    * @param command - The shell command to run
    * @param cwd - Working directory for the command
+   * @param threadId - Optional thread ID for dev server URL caching
    * @yields Output chunks from stdout/stderr
    */
-  async *runScript(key, command, cwd) {
+  async *runScript(key, command, cwd, threadId) {
     if (this.processes.has(key)) {
       this.stopScript(key);
     }
+    if (threadId) {
+      this.threadIds.set(key, threadId);
+    }
     const { shell, args: shellArgs } = getShellConfig();
     const child = spawnProcess(shell, [...shellArgs, command], {
       cwd,
@@ -25594,16 +26628,39 @@ var ScriptProcessManager = class {
     const decoder = new TextDecoder();
     const outputBuffer = [];
     let isDone = false;
+    let urlDetected = false;
+    let urlBuffer = "";
+    function appendOutput(text, isError) {
+      urlBuffer += text;
+      if (!urlDetected) {
+        const detectedUrl = detectDevServerUrl(urlBuffer);
+        if (detectedUrl) {
+          urlDetected = true;
+          if (threadId) {
+            devServerCache.setUrl(threadId, detectedUrl);
+          }
+          outputBuffer.push({ type: "url", url: detectedUrl });
+        }
+      }
+      if (isError) {
+        outputBuffer.push({ type: "error", message: text });
+      } else {
+        outputBuffer.push(text);
+      }
+    }
     child.stdout?.on("data", (data) => {
-      outputBuffer.push(decoder.decode(data));
+      appendOutput(decoder.decode(data), false);
     });
     child.stderr?.on("data", (data) => {
-      outputBuffer.push({ type: "error", message: decoder.decode(data) });
+      appendOutput(decoder.decode(data), true);
     });
     child.on("close", (code) => {
       if (code !== 0 && code !== null) {
         outputBuffer.push({ type: "error", message: `Process exited with code ${code}` });
       }
+      if (threadId && urlDetected) {
+        devServerCache.clearUrl(threadId);
+      }
       isDone = true;
     });
     child.on("error", (err) => {
@@ -25620,6 +26677,7 @@ var ScriptProcessManager = class {
       }
     } finally {
       this.processes.delete(key);
+      this.threadIds.delete(key);
     }
   }
   /**
@@ -25630,8 +26688,13 @@ var ScriptProcessManager = class {
   stopScript(key) {
     const entry = this.processes.get(key);
     if (!entry) return false;
+    const threadId = this.threadIds.get(key);
     killProcessTree2(entry.pid, entry.process);
     this.processes.delete(key);
+    this.threadIds.delete(key);
+    if (threadId) {
+      devServerCache.clearUrl(threadId);
+    }
     return true;
   }
   /**
@@ -25706,7 +26769,10 @@ async function handleRunProjectScript(c, threadManager) {
       return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
     }
     const key = `${thread.projectId}:${scriptName}`;
-    return streamAsyncGenerator(c, scriptProcessManager.runScript(key, command, thread.path));
+    return streamAsyncGenerator(
+      c,
+      scriptProcessManager.runScript(key, command, thread.path, threadId)
+    );
   } catch (error) {
     return errorResponse(
       c,
@@ -25748,10 +26814,10 @@ async function handleStopProjectScript(c, threadManager) {
 }
 
 // src/features/threads/threads.routes.ts
-function createThreadRoutes(threadManager, gitManager, conversationManager) {
+function createThreadRoutes(threadManager, gitManager2, conversationManager) {
   const router = new Hono12();
   router.post("/", async (c) => {
-    return handleCreateThread(c, threadManager, gitManager);
+    return handleCreateThread(c, threadManager, gitManager2);
   });
   router.get("/", async (c) => {
     const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), database_exports));
@@ -25836,6 +26902,9 @@ function createThreadRoutes(threadManager, gitManager, 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;
 }
 
@@ -26476,9 +27545,63 @@ async function gitGenerateCommitMessageHandler(c, metadataManager) {
 }
 
 // src/features/git/git-commit.route.ts
+var gitManager = new GitManagerImpl();
+async function getUniqueBranchName(baseBranchName, gitRoot, existingBranchNames) {
+  async function isBranchNameTaken(branchName) {
+    if (existingBranchNames.has(branchName)) {
+      return true;
+    }
+    return checkBranchExists(gitRoot, branchName);
+  }
+  if (!await isBranchNameTaken(baseBranchName)) {
+    return baseBranchName;
+  }
+  let counter = 2;
+  while (await isBranchNameTaken(`${baseBranchName}-${counter}`)) {
+    counter++;
+  }
+  return `${baseBranchName}-${counter}`;
+}
+async function maybeRenameInitialTarskBranch(gitRoot, threadId, commitMessage, metadataManager) {
+  const [commitCountBeforeCommit, currentBranch, threads] = await Promise.all([
+    getCommitCount(gitRoot),
+    getCurrentBranch(gitRoot),
+    metadataManager.loadThreads()
+  ]);
+  if (commitCountBeforeCommit !== 0) {
+    return;
+  }
+  const thread = threads.find((candidate) => candidate.id === threadId);
+  if (!thread) {
+    return;
+  }
+  if (currentBranch !== thread.currentBranch) {
+    return;
+  }
+  const expectedTarskBranchName = gitManager.sanitizeBranchName(thread.title);
+  if (currentBranch !== expectedTarskBranchName) {
+    return;
+  }
+  const requestedBranchName = gitManager.sanitizeBranchName(commitMessage);
+  if (!requestedBranchName || requestedBranchName === currentBranch) {
+    return;
+  }
+  const existingBranchNames = new Set(threads.map((candidate) => candidate.currentBranch));
+  existingBranchNames.delete(currentBranch);
+  const newBranchName = await getUniqueBranchName(
+    requestedBranchName,
+    gitRoot,
+    existingBranchNames
+  );
+  await renameCurrentBranch(gitRoot, newBranchName);
+  await metadataManager.updateThreadFields(threadId, { currentBranch: newBranchName });
+}
 async function gitCommitHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
+    if (!threadId) {
+      return c.json({ error: "Thread ID is required" }, 400);
+    }
     const body = await c.req.json();
     const { message } = body;
     if (!message) {
@@ -26500,6 +27623,7 @@ async function gitCommitHandler(c, metadataManager) {
       return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
     }
     await stageAllChanges(gitRoot);
+    await maybeRenameInitialTarskBranch(gitRoot, threadId, message, metadataManager);
     await commitChanges(gitRoot, message);
     return c.json({ success: true });
   } catch (error) {
@@ -26803,6 +27927,9 @@ async function gitLogHandler(c, metadataManager) {
 }
 
 // src/features/git/git-create-pr.route.ts
+function normalizeThreadTitle(title) {
+  return (title ?? "").trim().replace(/\s+/g, " ");
+}
 async function gitCreatePrHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
@@ -26812,6 +27939,9 @@ async function gitCreatePrHandler(c, metadataManager) {
     console.log(`[git-create-pr] PR title: "${title}"`);
     console.log(`[git-create-pr] PR description length: ${description?.length ?? 0} chars`);
     const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
+    if (!threadId) {
+      return c.json({ error: "Thread ID is required" }, 400);
+    }
     if (!thread) {
       console.log(`[git-create-pr] Thread not found: ${threadId}`);
       return c.json({ error: "Thread not found" }, 404);
@@ -26834,10 +27964,17 @@ async function gitCreatePrHandler(c, metadataManager) {
     }
     const currentBranch = await getCurrentBranch(gitRoot);
     console.log(`[git-create-pr] Current branch: ${currentBranch}`);
+    const prTitle = title ?? currentBranch;
     console.log(`[git-create-pr] Creating PR with GitHub CLI...`);
-    const prUrl = await createPullRequest(gitRoot, title ?? currentBranch, description ?? "");
+    const prUrl = await createPullRequest(gitRoot, prTitle, description ?? "");
     console.log(`[git-create-pr] \u2713 PR created successfully: ${prUrl}`);
-    return c.json({ success: true, prUrl });
+    const normalizedPrTitle = normalizeThreadTitle(prTitle);
+    if (normalizedPrTitle !== thread.title) {
+      const threadUpdates = { title: normalizedPrTitle };
+      await metadataManager.updateThreadFields(threadId, threadUpdates);
+      console.log(`[git-create-pr] \u2713 Updated thread title to PR title: ${normalizedPrTitle}`);
+    }
+    return c.json({ success: true, prUrl, title: normalizedPrTitle });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to create PR";
     console.log(`[git-create-pr] \u2717 PR creation failed: ${message}`);
@@ -27163,7 +28300,7 @@ function sanitizeBranchName(name) {
   }
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9\-_/.]/g, "").replace(/^[/.]+|[/.]+$/g, "").replace(/-+/g, "-") || "branch";
 }
-function checkBranchExists(gitRoot, branchName) {
+function checkBranchExists2(gitRoot, branchName) {
   return new Promise((resolve8) => {
     const proc = spawnProcess(
       "git",
@@ -27227,12 +28364,12 @@ async function gitCreateRepoHandler(c, metadataManager) {
     }
     const repoUrl = await createGitHubRepo(gitRoot, repoName, description, isPrivate);
     let branchName = sanitizeBranchName(generateRandomThreadName());
-    let branchExists = await checkBranchExists(gitRoot, branchName);
+    let branchExists = await checkBranchExists2(gitRoot, branchName);
     let counter = 2;
     const baseBranchName = branchName;
     while (branchExists) {
       branchName = `${baseBranchName}-${counter}`;
-      branchExists = await checkBranchExists(gitRoot, branchName);
+      branchExists = await checkBranchExists2(gitRoot, branchName);
       counter++;
     }
     await createAndCheckoutBranch(gitRoot, branchName);
@@ -27285,7 +28422,7 @@ function sanitizeBranchName2(name) {
   }
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9\-_/.]/g, "").replace(/^[/.]+|[/.]+$/g, "").replace(/-+/g, "-") || "branch";
 }
-function checkBranchExists2(gitRoot, branchName) {
+function checkBranchExists3(gitRoot, branchName) {
   return new Promise((resolve8) => {
     const proc = spawnProcess(
       "git",
@@ -27348,7 +28485,7 @@ async function gitCreateBranchHandler(c, metadataManager) {
     if (!branchName) {
       return c.json({ error: "Invalid branch name" }, 400);
     }
-    const branchExists = await checkBranchExists2(gitRoot, branchName);
+    const branchExists = await checkBranchExists3(gitRoot, branchName);
     if (body.branchName) {
       if (branchExists) {
         return c.json({ error: `Branch "${branchName}" already exists` }, 409);
@@ -27359,7 +28496,7 @@ async function gitCreateBranchHandler(c, metadataManager) {
       let exists = branchExists;
       while (exists) {
         branchName = `${baseBranchName}-${counter}`;
-        exists = await checkBranchExists2(gitRoot, branchName);
+        exists = await checkBranchExists3(gitRoot, branchName);
         counter++;
       }
     }
@@ -27731,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 = "";
@@ -27767,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);
@@ -27777,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) {
@@ -27974,51 +29111,12 @@ async function gitCheckpointRestoreHandler(c, metadataManager) {
 }
 
 // src/features/git/git-rename-branch.route.ts
-init_utils();
 function sanitizeBranchName3(name) {
   if (!name || typeof name !== "string") {
     return "";
   }
   return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-zA-Z0-9\-_/.]/g, "").replace(/^[/.]+|[/.]+$/g, "").replace(/-+/g, "-") || "";
 }
-function checkBranchExists3(gitRoot, branchName) {
-  return new Promise((resolve8) => {
-    const proc = spawnProcess(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
-      {
-        cwd: gitRoot
-      }
-    );
-    proc.on("close", (code) => {
-      resolve8(code === 0);
-    });
-    proc.on("error", () => {
-      resolve8(false);
-    });
-  });
-}
-function renameBranch(gitRoot, newBranchName) {
-  return new Promise((resolve8, reject) => {
-    const proc = spawnProcess("git", ["branch", "-m", newBranchName], {
-      cwd: gitRoot
-    });
-    let err = "";
-    if (proc.stderr) {
-      proc.stderr.on("data", (d) => {
-        err += d.toString();
-      });
-    }
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve8();
-      } else {
-        reject(new Error(err || `Failed to rename branch to "${newBranchName}"`));
-      }
-    });
-    proc.on("error", reject);
-  });
-}
 async function gitRenameBranchHandler(c, metadataManager) {
   try {
     const threadId = c.req.param("threadId");
@@ -28046,11 +29144,11 @@ async function gitRenameBranchHandler(c, metadataManager) {
     } catch {
       return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
     }
-    const branchExists = await checkBranchExists3(gitRoot, newBranchName);
+    const branchExists = await checkBranchExists(gitRoot, newBranchName);
     if (branchExists) {
       return c.json({ error: `Branch "${newBranchName}" already exists` }, 409);
     }
-    await renameBranch(gitRoot, newBranchName);
+    await renameCurrentBranch(gitRoot, newBranchName);
     const threads = await metadataManager.loadThreads();
     const threadIndex = threads.findIndex((t) => t.id === threadId);
     if (threadIndex !== -1) {
@@ -28292,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 = [
@@ -28415,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 {
@@ -28429,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");
 }
@@ -28632,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;
 }
@@ -28846,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";
@@ -28858,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);
 }
@@ -29212,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() {
@@ -29250,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) {
@@ -29431,23 +30846,12 @@ function createBrowserRoutes() {
 
 // src/features/voice-model/voice-model.routes.ts
 import { Hono as Hono24 } from "hono";
-var VOICE_MODEL_URLS = {
-  default: "https://install.tarsk.io/voice-models/ggml-tiny.en.bin",
-  tiny: "https://install.tarsk.io/voice-models/ggml-tiny.en-q5_1.bin"
-};
-function getVoiceModelUrl(model) {
-  if (model === "tiny") {
-    return VOICE_MODEL_URLS.tiny;
-  }
-  return VOICE_MODEL_URLS.default;
-}
+var VOICE_MODEL_URL = "https://install.tarsk.io/voice-models/vosk-model-small-en-us-0.15.tar.gz";
 function createVoiceModelRoutes() {
   const router = new Hono24();
   router.get("/download", async (c) => {
-    const selectedModel = c.req.query("model");
-    const modelUrl = getVoiceModelUrl(selectedModel);
     try {
-      const response = await fetch(modelUrl);
+      const response = await fetch(VOICE_MODEL_URL);
       if (!response.ok) {
         return errorResponse(
           c,
@@ -29458,8 +30862,7 @@ function createVoiceModelRoutes() {
       }
       const contentLength = response.headers.get("content-length");
       const headers = {
-        "Content-Type": "application/octet-stream",
-        "X-Tarsk-Voice-Model": selectedModel === "tiny" ? "tiny" : "default"
+        "Content-Type": "application/gzip"
       };
       if (contentLength) {
         headers["Content-Length"] = contentLength;
@@ -29675,7 +31078,7 @@ async function startTarskServer(options) {
 }
 async function startTarskServerInternal(options) {
   const { isDebug: isDebug2, publicDir: publicDirOverride } = options;
-  const port = isDebug2 ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
+  const initialPort = isDebug2 ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
   const app = new Hono28();
   app.use("/*", cors());
   app.use("/*", async (c, next) => {
@@ -29687,7 +31090,9 @@ async function startTarskServerInternal(options) {
     if (c.req.path.startsWith("/api/")) {
       const method = c.req.method;
       const reqPath = c.req.path;
-      const fullUrl = `http://localhost:${port}${reqPath}`;
+      const hostHeader = c.req.header("host") ?? `localhost:${initialPort}`;
+      const requestUrl = new URL(c.req.url);
+      const fullUrl = `${requestUrl.protocol}//${hostHeader}${reqPath}`;
       const isThreadMessages = reqPath.startsWith("/api/threads/") && reqPath.endsWith("/messages");
       if (!fullUrl.includes("processing") && !reqPath.startsWith("/api/logs") && !isThreadMessages) {
         console.log(`${method} ${fullUrl}`);
@@ -29697,17 +31102,17 @@ async function startTarskServerInternal(options) {
   });
   const dataDir = getDataDir();
   const metadataManager = new MetadataManager(dataDir);
-  const gitManager = new GitManagerImpl();
+  const gitManager2 = new GitManagerImpl();
   const processingStateManager = new ProcessingStateManagerImpl();
   const projectManager = new ProjectManagerImpl(
     dataDir,
     metadataManager,
-    gitManager,
+    gitManager2,
     processingStateManager
   );
   const threadManager = new ThreadManagerImpl(
     metadataManager,
-    gitManager,
+    gitManager2,
     processingStateManager,
     dataDir
   );
@@ -29720,7 +31125,8 @@ async function startTarskServerInternal(options) {
     return c.json({
       status: "ok",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      service: "project-threads-manager-cli"
+      service: "project-threads-manager-cli",
+      isDevMode: port !== initialPort
     });
   });
   app.get("/api/programs", (c) => {
@@ -29733,10 +31139,10 @@ 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, gitManager, conversationManager));
+  app.route("/api/threads", createThreadRoutes(threadManager, gitManager2, conversationManager));
   app.route("/api/threads", createUserTaskRoutes());
   app.route(
     "/api/chat",
@@ -29786,16 +31192,37 @@ async function startTarskServerInternal(options) {
       `No static frontend assets found. Expected one of: ${prodPublicDir}, ${devCopiedPublicDir}, ${appDistDir}. Build the app first with \`cd ../app && bun run build\`.`
     );
   }
+  function isStaticAssetPath(requestPath) {
+    if (requestPath.startsWith("/assets/")) {
+      return true;
+    }
+    const lastSegment = requestPath.split("/").pop() ?? "";
+    return lastSegment.includes(".") && !lastSegment.endsWith(".html");
+  }
+  function setNoCacheIndexHeaders(c) {
+    c.header("Cache-Control", "no-cache, no-store, must-revalidate");
+  }
   app.use("/*", async (c, next) => {
     if (c.req.path.startsWith("/api/")) {
       return next();
     }
-    return serveStatic({ root: resolvedPublicDir })(c, next);
+    return serveStatic({
+      root: resolvedPublicDir,
+      onFound: (_path, context) => {
+        if (context.req.path === "/" || context.req.path === "/index.html") {
+          setNoCacheIndexHeaders(context);
+        }
+      }
+    })(c, next);
   });
   app.get("*", async (c, next) => {
     if (c.req.path.startsWith("/api/")) {
       return next();
     }
+    if (isStaticAssetPath(c.req.path)) {
+      return next();
+    }
+    setNoCacheIndexHeaders(c);
     return serveStatic({
       path: path5.join(resolvedPublicDir, "index.html")
     })(c, next);
@@ -29812,16 +31239,22 @@ async function startTarskServerInternal(options) {
   });
   const serverBindMode = readServerBindMode();
   const hostname2 = getServerBindHostname(serverBindMode);
-  const url = `http://localhost:${port}`;
-  const bound = await listenForTarskServer({
+  const port = await listenForTarskServer({
     fetch: app.fetch,
     hostname: hostname2,
-    onListening: () => {
+    onPortConflict: (candidatePort) => {
+      process.stdout.write(
+        `Port ${candidatePort} is already in use, trying ${candidatePort + 1}.
+`
+      );
+    },
+    onListening: (listeningPort) => {
+      const url = `http://localhost:${listeningPort}`;
       process.stdout.write(`Tarsk started on ${url}
 `);
       if (serverBindMode === "network") {
         for (const address of getLocalNetworkAddresses()) {
-          process.stdout.write(`  Network: http://${address}:${port}
+          process.stdout.write(`  Network: http://${address}:${listeningPort}
 `);
         }
       }
@@ -29830,38 +31263,48 @@ async function startTarskServerInternal(options) {
         });
       }
     },
-    port
+    port: initialPort
   });
-  if (!bound) {
-    return { url, port, bound: false };
-  }
-  return { url, port, bound: true };
+  return {
+    url: `http://localhost:${port}`,
+    port,
+    bound: true,
+    isDevMode: port !== initialPort
+  };
 }
 async function listenForTarskServer(options) {
-  const server = createAdaptorServer({
-    fetch: options.fetch,
-    hostname: options.hostname,
-    port: options.port
-  });
-  return new Promise((resolve8, reject) => {
-    server.once("error", (error) => {
-      if (error.code === "EADDRINUSE") {
-        resolve8(false);
-        return;
+  let port = options.port;
+  while (true) {
+    const server = createAdaptorServer({
+      fetch: options.fetch,
+      hostname: options.hostname,
+      port
+    });
+    const result = await new Promise((resolve8, reject) => {
+      server.once("error", (error) => {
+        if (error.code === "EADDRINUSE") {
+          resolve8("in-use");
+          return;
+        }
+        startPromise = null;
+        reject(error);
+      });
+      function onListening() {
+        resolve8("listening");
+      }
+      if (options.hostname) {
+        server.listen(port, options.hostname, onListening);
+      } else {
+        server.listen(port, onListening);
       }
-      startPromise = null;
-      reject(error);
     });
-    function onListening() {
-      options.onListening();
-      resolve8(true);
+    if (result === "listening") {
+      options.onListening(port);
+      return port;
     }
-    if (options.hostname) {
-      server.listen(options.port, options.hostname, onListening);
-    } else {
-      server.listen(options.port, onListening);
-    }
-  });
+    options.onPortConflict(port);
+    port += 1;
+  }
 }
 
 // src/index.ts