tarsk 0.5.43 → 0.5.44

package/dist/index.js

@@ -9080,12 +9080,87 @@ function stageAllChanges(gitRoot) {
     proc.on("error", reject);
   });
 }
+function getCommitCount(gitRoot) {
+  return new Promise((resolve8, reject) => {
+    const proc = spawnProcess("git", ["rev-list", "--count", "HEAD"], { cwd: gitRoot });
+    let out = "";
+    let err = "";
+    if (proc.stdout) {
+      proc.stdout.on("data", (d) => {
+        out += d.toString();
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (d) => {
+        err += d.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      if (code === 0) {
+        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", 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 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();
-      else reject(new Error("Failed to commit changes"));
+      if (code === 0) resolve8({ createdCommit: true });
+      else reject(new Error(err.trim() || "Failed to commit changes"));
     });
     proc.on("error", reject);
   });
@@ -14661,7 +14736,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 +14834,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();
@@ -19449,7 +19525,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 +19539,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 +19632,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 +19646,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 +19737,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 +20907,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 +21604,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 +21613,7 @@ var ProjectManagerImpl = class {
     this.projectCreator = new ProjectCreator(
       rootFolder,
       metadataManager,
-      gitManager,
+      gitManager2,
       processingStateManager,
       {
         suggestRunCommand: (id) => this.suggestRunCommand(id),
@@ -23326,9 +23404,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 +23885,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 +23911,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));
@@ -24441,9 +24519,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([]);
@@ -25568,17 +25648,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 +25679,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 +25728,7 @@ var ScriptProcessManager = class {
       }
     } finally {
       this.processes.delete(key);
+      this.threadIds.delete(key);
     }
   }
   /**
@@ -25630,8 +25739,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 +25820,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 +25865,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));
@@ -26476,9 +26593,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 +26671,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 +26975,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 +26987,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 +27012,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 +27348,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 +27412,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 +27470,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 +27533,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 +27544,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++;
       }
     }
@@ -27974,51 +28159,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 +28192,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) {
@@ -29431,23 +29577,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 +29593,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 +29809,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 +29821,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 +29833,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 +29856,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) => {
@@ -29736,7 +29873,7 @@ async function startTarskServerInternal(options) {
   app.route("/api/projects", createProjectRoutes(projectManager, threadManager));
   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 +29923,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 +29970,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 +29994,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 (options.hostname) {
-      server.listen(options.port, options.hostname, onListening);
-    } else {
-      server.listen(options.port, onListening);
+    if (result === "listening") {
+      options.onListening(port);
+      return port;
     }
-  });
+    options.onPortConflict(port);
+    port += 1;
+  }
 }
 
 // src/index.ts