tarsk 0.4.30 → 0.5.32

package/dist/index.js

@@ -265,6 +265,9 @@ async function initializeSchema(db) {
         request_model TEXT NOT NULL,
         request_attachments TEXT,
         request_planMode INTEGER,
+        request_ralphMode INTEGER NOT NULL DEFAULT 0,
+        request_imageMode INTEGER NOT NULL DEFAULT 0,
+        request_checkpointRef TEXT,
         response_content TEXT,
         response_events TEXT,
         response_completedAt TEXT,
@@ -307,6 +310,16 @@ async function initializeSchema(db) {
         cachedAt TEXT NOT NULL
       )
     `);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS user_tasks (
+        id TEXT PRIMARY KEY,
+        threadId TEXT NOT NULL,
+        content TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        FOREIGN KEY (threadId) REFERENCES threads(id) ON DELETE CASCADE
+      )
+    `);
     await db.execute(`
       CREATE TABLE IF NOT EXISTS code_files (
         id INTEGER PRIMARY KEY,
@@ -356,6 +369,9 @@ async function initializeSchema(db) {
     await db.execute(`
       CREATE INDEX IF NOT EXISTS idx_project_todos_projectId ON project_todos(projectId)
     `);
+    await db.execute(`
+      CREATE INDEX IF NOT EXISTS idx_user_tasks_threadId ON user_tasks(threadId)
+    `);
     await db.execute(`
       CREATE INDEX IF NOT EXISTS idx_conversation_history_threadId ON conversation_history(threadId)
     `);
@@ -674,6 +690,15 @@ async function runMigrations(db) {
       );
       await db.execute(`ALTER TABLE conversation_history ADD COLUMN response_imageUrl TEXT`);
     }
+    const hasCheckpointRef = convInfo.rows.some(
+      (col) => col.name === "request_checkpointRef"
+    );
+    if (!hasCheckpointRef) {
+      tarskDebugLog(
+        "[db] Running migration: Adding request_checkpointRef column to conversation_history"
+      );
+      await db.execute(`ALTER TABLE conversation_history ADD COLUMN request_checkpointRef TEXT`);
+    }
     const projectTodosInfo = await db.execute(`PRAGMA table_info(project_todos)`);
     const hasThreadIdColumn = projectTodosInfo.rows.some(
       (col) => col.name === "threadId"
@@ -695,6 +720,25 @@ async function runMigrations(db) {
         )
       `);
     }
+    const userTasksExists = await db.execute(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name='user_tasks'`
+    );
+    if (userTasksExists.rows.length === 0) {
+      tarskDebugLog("[db] Running migration: Creating user_tasks table");
+      await db.execute(`
+        CREATE TABLE user_tasks (
+          id TEXT PRIMARY KEY,
+          threadId TEXT NOT NULL,
+          content TEXT NOT NULL,
+          createdAt TEXT NOT NULL,
+          updatedAt TEXT NOT NULL,
+          FOREIGN KEY (threadId) REFERENCES threads(id) ON DELETE CASCADE
+        )
+      `);
+      await db.execute(`
+        CREATE INDEX idx_user_tasks_threadId ON user_tasks(threadId)
+      `);
+    }
     const codeFilesExists = await db.execute(
       `SELECT name FROM sqlite_master WHERE type='table' AND name='code_files'`
     );
@@ -930,7 +974,7 @@ function estimateTokenCount(text) {
 
 // src/server.ts
 import fs3 from "fs";
-import { Hono as Hono23 } from "hono";
+import { Hono as Hono24 } from "hono";
 import { cors } from "hono/cors";
 import open3 from "open";
 import path4 from "path";
@@ -5077,10 +5121,12 @@ async function createCodingTools(cwd, options) {
     );
   }
   let mcpTools = [];
-  try {
-    mcpTools = await createMCPTools(cwd);
-  } catch (error) {
-    console.warn(`[Tools] Failed to load MCP tools for ${cwd}:`, error);
+  if (options?.loadMcpTools !== false) {
+    try {
+      mcpTools = await createMCPTools(cwd);
+    } catch (error) {
+      console.warn(`[Tools] Failed to load MCP tools for ${cwd}:`, error);
+    }
   }
   const deferredTools = /* @__PURE__ */ new Map();
   if (deferOption === false) {
@@ -6874,6 +6920,114 @@ async function readEnvFile() {
 // src/features/ask-user/ask-user.routes.ts
 import { Hono } from "hono";
 
+// src/agent/agent-run-guard.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var LONG_RUNNING_TURN_LIMIT = 50;
+var LONG_RUNNING_DURATION_MS = 10 * 60 * 1e3;
+var LONG_RUNNING_CONFIRMATION_QUESTION = "The agent has been working for a long time. Do you want to continue?";
+var LONG_RUNNING_CONFIRMATION_OPTIONS = ["Yes", "No"];
+function getLongRunningResolvers() {
+  const pendingQuestions2 = globalThis;
+  if (!pendingQuestions2.__tarskLongRunningResolvers) {
+    pendingQuestions2.__tarskLongRunningResolvers = /* @__PURE__ */ new Map();
+  }
+  return pendingQuestions2.__tarskLongRunningResolvers;
+}
+function createLongRunningGuardState(now = Date.now()) {
+  return {
+    startedAt: now,
+    turnCount: 0,
+    prompted: false
+  };
+}
+function incrementLongRunningTurn(state) {
+  state.turnCount += 1;
+}
+function resetLongRunningGuard(state, now = Date.now()) {
+  state.startedAt = now;
+  state.turnCount = 0;
+  state.prompted = false;
+}
+function shouldPromptForLongRunningConfirmation(state, now = Date.now()) {
+  if (state.prompted) return false;
+  return state.turnCount > LONG_RUNNING_TURN_LIMIT || now - state.startedAt > LONG_RUNNING_DURATION_MS;
+}
+function createLongRunningConfirmationRequest() {
+  const toolCallId = `long-running-confirmation-${randomUUID2()}`;
+  const event = {
+    type: "long_running_confirmation",
+    prompt: {
+      toolCallId,
+      question: LONG_RUNNING_CONFIRMATION_QUESTION,
+      options: [...LONG_RUNNING_CONFIRMATION_OPTIONS],
+      context: "The current agent run has exceeded 50 turns or 10 minutes. Choose Yes to continue and reset the limit, or No to stop."
+    },
+    content: JSON.stringify([
+      {
+        type: "tool_use",
+        name: "ask_user",
+        id: toolCallId,
+        input: {
+          question: LONG_RUNNING_CONFIRMATION_QUESTION,
+          options: [...LONG_RUNNING_CONFIRMATION_OPTIONS],
+          context: "The current agent run has exceeded 50 turns or 10 minutes. Choose Yes to continue and reset the limit, or No to stop."
+        }
+      }
+    ])
+  };
+  return {
+    toolCallId,
+    event,
+    waitForAnswer: (signal) => {
+      return new Promise((resolve6, reject) => {
+        const resolvers = getLongRunningResolvers();
+        const cleanup = () => {
+          resolvers.delete(toolCallId);
+          if (signal) {
+            signal.removeEventListener("abort", onAbort);
+          }
+        };
+        const onAbort = () => {
+          cleanup();
+          reject(new Error("Operation aborted"));
+        };
+        if (signal?.aborted) {
+          cleanup();
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        resolvers.set(toolCallId, {
+          resolve: (answer) => {
+            cleanup();
+            resolve6(answer);
+          },
+          reject: (error) => {
+            cleanup();
+            reject(error);
+          }
+        });
+      });
+    }
+  };
+}
+function resolveLongRunningConfirmation(toolCallId, answer) {
+  const resolver = getLongRunningResolvers().get(toolCallId);
+  if (!resolver) {
+    return false;
+  }
+  resolver.resolve(answer);
+  return true;
+}
+function normalizeLongRunningConfirmationAnswer(answer) {
+  const normalized = answer.trim().toLowerCase();
+  if (normalized === "yes") return "yes";
+  if (normalized === "no") return "no";
+  return null;
+}
+
 // src/core/response-builder.ts
 var ResponseBuilder = class {
   /**
@@ -7014,7 +7168,7 @@ function createAskUserRoutes() {
           400
         );
       }
-      const resolved = submitAnswer(toolCallId, answer);
+      const resolved = submitAnswer(toolCallId, answer) || resolveLongRunningConfirmation(toolCallId, answer);
       if (!resolved) {
         return errorResponse(
           c,
@@ -7041,7 +7195,7 @@ function createAskUserRoutes() {
 import { Hono as Hono2 } from "hono";
 
 // src/features/chat/chat-post.route.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/features/skills/skills.manager.ts
 import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
@@ -7615,7 +7769,7 @@ import { join as join15 } from "path";
 
 // src/features/project-todos/project-todos.database.ts
 init_database();
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 function serializeTodo(row) {
   return {
     ...row,
@@ -7640,7 +7794,7 @@ async function getTodoById(db, todoId) {
 }
 async function insertTodo(projectId, title, description) {
   const db = await getDatabase();
-  const id = randomUUID2();
+  const id = randomUUID3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await db.execute({
     sql: `INSERT INTO project_todos (id, projectId, title, description, status, working, createdAt, updatedAt)
@@ -7750,7 +7904,7 @@ async function invalidateGitStatusCache(db, threadId) {
 
 // src/features/account/account-get-info.route.ts
 init_database();
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/core/crypto.ts
 init_database();
@@ -7903,7 +8057,7 @@ async function getOrCreateClientReferenceId() {
   if (existing !== null && existing !== void 0) {
     return existing;
   }
-  const id = randomUUID3();
+  const id = randomUUID4();
   await setState(db, KEY_CLIENT_REFERENCE_ID, id);
   return id;
 }
@@ -8185,7 +8339,8 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
       provider,
       attachments,
       planMode,
-      ralphMode
+      ralphMode,
+      checkpointRef
     } = body;
     let model = baseModel;
     if (provider && typeof provider === "string") {
@@ -8284,7 +8439,7 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
     }
     let conversationId = thread.currentConversationId;
     if (!conversationId) {
-      conversationId = randomUUID4();
+      conversationId = randomUUID5();
       const db = await getDatabase();
       await db.execute({
         sql: "DELETE FROM todos WHERE threadId = ?",
@@ -8338,7 +8493,8 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
       attachments,
       planMode,
       void 0,
-      ralphMode
+      ralphMode,
+      typeof checkpointRef === "string" ? checkpointRef : void 0
     );
     const history = await conversationManager.getConversationHistoryByConversationId(
       threadId,
@@ -8366,14 +8522,18 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
     }
     processingStateManager.setProcessing(threadId);
     processingStateManager.registerAbortController(threadId, abortController);
+    const longRunningGuard = createLongRunningGuardState();
     async function* executeAgent(prompt, ctx, signal, history2, captured) {
       for await (const event of agentExecutor.execute(prompt, ctx, signal, history2)) {
         captured.events.push(event);
+        if (event.type === "message" || event.type === "toolcall_delta" || event.type === "subagent_event" || event.type === "subagent_start" || event.type === "subagent_complete") {
+          incrementLongRunningTurn(longRunningGuard);
+        }
         if (event.type === "message" && event.content) {
           captured.fullContent += event.content;
         }
-        if (event.type === "message" && typeof event.content === "string" && (event.role === "tool" || isToolLikeContent(event.content))) {
-          const thinkingEvent = { type: "thinking", content: event.content };
+        if (event.type === "message" && typeof event.content === "string" && (event.role === "tool" || isToolLikeContent(event.content)) || event.type === "long_running_confirmation") {
+          const thinkingEvent = { type: "thinking", content: event.content ?? "" };
           processingStateManager.pushEvent(threadId, thinkingEvent);
           yield thinkingEvent;
           continue;
@@ -8384,6 +8544,44 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
     }
     async function* chatExecutionGenerator() {
       const captured = { events: [], fullContent: "" };
+      async function completeCapturedMessage(completedMessageId, completedCaptured) {
+        const finalContent = extractAssistantContent(
+          completedCaptured.events,
+          completedCaptured.fullContent
+        );
+        await conversationManager.completeMessage(
+          completedMessageId,
+          finalContent,
+          completedCaptured.events
+        );
+        return finalContent;
+      }
+      async function* confirmLongRunningWorkIfNeeded(currentMessageId, currentCaptured) {
+        if (!shouldPromptForLongRunningConfirmation(longRunningGuard)) {
+          return true;
+        }
+        longRunningGuard.prompted = true;
+        const confirmation = createLongRunningConfirmationRequest();
+        currentCaptured.events.push(confirmation.event);
+        processingStateManager.pushEvent(threadId, confirmation.event);
+        yield confirmation.event;
+        const answer = await confirmation.waitForAnswer(abortController.signal).catch(() => "No");
+        const normalizedAnswer = normalizeLongRunningConfirmationAnswer(answer);
+        if (normalizedAnswer === "yes") {
+          resetLongRunningGuard(longRunningGuard);
+          return true;
+        }
+        abortController.abort();
+        const stopEvent = {
+          type: "thinking",
+          content: "[Agent] Stopped long-running execution at user request."
+        };
+        currentCaptured.events.push(stopEvent);
+        processingStateManager.pushEvent(threadId, stopEvent);
+        yield stopEvent;
+        await completeCapturedMessage(currentMessageId, currentCaptured);
+        return false;
+      }
       try {
         yield* executeAgent(
           content,
@@ -8392,8 +8590,16 @@ async function postChatMessage(c, threadManager, agentExecutor, conversationMana
           conversationHistory,
           captured
         );
-        const finalContent = extractAssistantContent(captured.events, captured.fullContent);
-        await conversationManager.completeMessage(messageId, finalContent, captured.events);
+        const initialConfirmation = confirmLongRunningWorkIfNeeded(messageId, captured);
+        const initialDecision = await initialConfirmation.next();
+        if (!initialDecision.done) {
+          yield initialDecision.value;
+          const postPromptDecision = await initialConfirmation.next();
+          if (postPromptDecision.value === false) {
+            return;
+          }
+        }
+        const finalContent = await completeCapturedMessage(messageId, captured);
         console.log("[ChatRoute] Conversation captured:", {
           messageId,
           eventCount: captured.events.length,
@@ -8421,7 +8627,7 @@ $ ${validationScript}`
               console.log("[ChatRoute] Validation script passed");
               const passEvent = {
                 type: "thinking",
-                content: `[Validated] Validation passed (exit code 0)${result.output ? `
+                content: `[Validated] Validated (exit code 0)${result.output ? `
 ${result.output}` : ""}`
               };
               processingStateManager.pushEvent(threadId, passEvent);
@@ -8463,14 +8669,21 @@ ${result.output}`;
               updatedHistory,
               validationCaptured
             );
-            const validationContent = extractAssistantContent(
-              validationCaptured.events,
-              validationCaptured.fullContent
+            const validationConfirmation = confirmLongRunningWorkIfNeeded(
+              validationMessageId,
+              validationCaptured
             );
-            await conversationManager.completeMessage(
+            const validationDecision = await validationConfirmation.next();
+            if (!validationDecision.done) {
+              yield validationDecision.value;
+              const postValidationDecision = await validationConfirmation.next();
+              if (postValidationDecision.value === false) {
+                return;
+              }
+            }
+            const validationContent = await completeCapturedMessage(
               validationMessageId,
-              validationContent,
-              validationCaptured.events
+              validationCaptured
             );
             conversationHistory.push({
               userMessage: validationPrompt,
@@ -8513,7 +8726,7 @@ ${result.output}`;
             };
             processingStateManager.pushEvent(threadId, iterationEvent);
             yield iterationEvent;
-            const newConversationId = randomUUID4();
+            const newConversationId = randomUUID5();
             await threadManager.updateThread(threadId, {
               currentConversationId: newConversationId
             });
@@ -8539,15 +8752,16 @@ ${result.output}`;
               // Empty history - fresh context
               iterCaptured
             );
-            const iterContent = extractAssistantContent(
-              iterCaptured.events,
-              iterCaptured.fullContent
-            );
-            await conversationManager.completeMessage(
-              iterMessageId,
-              iterContent,
-              iterCaptured.events
-            );
+            const ralphConfirmation = confirmLongRunningWorkIfNeeded(iterMessageId, iterCaptured);
+            const ralphDecision = await ralphConfirmation.next();
+            if (!ralphDecision.done) {
+              yield ralphDecision.value;
+              const postRalphDecision = await ralphConfirmation.next();
+              if (postRalphDecision.value === false) {
+                return;
+              }
+            }
+            await completeCapturedMessage(iterMessageId, iterCaptured);
             decrementBalance().catch((err) => {
               console.error("[ChatRoute] Failed to decrement balance:", err);
             });
@@ -8637,7 +8851,7 @@ ${result.output}`;
 }
 
 // src/features/chat/chat-delete.route.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 init_database();
 async function deleteChat(c, threadManager) {
   try {
@@ -8659,7 +8873,7 @@ async function deleteChat(c, threadManager) {
       sql: "DELETE FROM todos WHERE threadId = ?",
       args: [threadId]
     });
-    const newConversationId = randomUUID5();
+    const newConversationId = randomUUID6();
     await threadManager.updateThread(threadId, { currentConversationId: newConversationId });
     return successResponse(
       c,
@@ -8688,13 +8902,10 @@ function subscribeToChatStream(c, processingStateManager) {
     return c.json({ error: "Thread is not currently processing" }, 404);
   }
   return stream2(c, async (writer) => {
-    const buffered = processingStateManager.getBufferedEvents(threadId);
-    for (const event of buffered) {
-      await writer.write(JSON.stringify(event) + "\n");
-    }
     let resolve6 = null;
     const queue = [];
     let done = false;
+    const replay = processingStateManager.getBufferedEvents(threadId).slice();
     const unsubscribe = processingStateManager.subscribe(threadId, (event) => {
       if (event.type === "complete") {
         done = true;
@@ -8707,6 +8918,7 @@ function subscribeToChatStream(c, processingStateManager) {
         resolve6 = null;
       }
     });
+    const finishedBeforeSubscribe = !processingStateManager.isProcessing(threadId);
     writer.onAbort(() => {
       done = true;
       unsubscribe();
@@ -8716,6 +8928,16 @@ function subscribeToChatStream(c, processingStateManager) {
       }
     });
     try {
+      for (const event of replay) {
+        await writer.write(JSON.stringify(event) + "\n");
+        if (event.type === "complete") {
+          done = true;
+        }
+      }
+      if (finishedBeforeSubscribe && !done) {
+        await writer.write(JSON.stringify({ type: "complete", content: "" }) + "\n");
+        return;
+      }
       while (!done) {
         while (queue.length > 0) {
           const event = queue.shift();
@@ -8771,18 +8993,18 @@ function createChatRoutes(threadManager, agentExecutor, conversationManager, pro
 init_database();
 
 // src/features/conversations/conversations.database.ts
-import { randomUUID as randomUUID6 } from "crypto";
-async function insertMessage(db, threadId, conversationId, message, model, attachments, planMode, imageMode, ralphMode) {
+import { randomUUID as randomUUID7 } from "crypto";
+async function insertMessage(db, threadId, conversationId, message, model, attachments, planMode, imageMode, ralphMode, checkpointRef) {
   try {
-    const messageId = randomUUID6();
+    const messageId = randomUUID7();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     await db.execute(
       `
       INSERT INTO conversation_history (
         id, threadId, conversationId, timestamp, status,
-        request_message, request_model, request_attachments, request_planMode, request_ralphMode, request_imageMode
+        request_message, request_model, request_attachments, request_planMode, request_ralphMode, request_imageMode, request_checkpointRef
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
       [
         messageId,
@@ -8795,7 +9017,8 @@ async function insertMessage(db, threadId, conversationId, message, model, attac
         attachments ? JSON.stringify(attachments) : null,
         planMode ? 1 : 0,
         ralphMode ? 1 : 0,
-        imageMode ? 1 : 0
+        imageMode ? 1 : 0,
+        checkpointRef ?? null
       ]
     );
     return messageId;
@@ -8999,7 +9222,8 @@ function deserializeMessage(row) {
       ...row.request_attachments && { attachments: JSON.parse(row.request_attachments) },
       ...row.request_planMode === 1 && { planMode: true },
       ...row.request_ralphMode === 1 && { ralphMode: true },
-      ...row.request_imageMode === 1 && { imageMode: true }
+      ...row.request_imageMode === 1 && { imageMode: true },
+      ...row.request_checkpointRef && { checkpointRef: row.request_checkpointRef }
     },
     response: row.response_content != null ? {
       content: row.response_content,
@@ -9078,7 +9302,7 @@ var ConversationManagerImpl = class {
   /**
    * Starts a new conversation message
    */
-  async startMessage(threadId, _threadPath, conversationId, message, model, attachments, planMode, imageMode, ralphMode) {
+  async startMessage(threadId, _threadPath, conversationId, message, model, attachments, planMode, imageMode, ralphMode, checkpointRef) {
     try {
       if (!this.db) {
         await this.initialize();
@@ -9092,7 +9316,8 @@ var ConversationManagerImpl = class {
         attachments,
         planMode,
         imageMode,
-        ralphMode
+        ralphMode,
+        checkpointRef
       );
     } catch (error) {
       console.error("Failed to start conversation message:", error);
@@ -9978,7 +10203,8 @@ async function computeContextBreakdown(threadId, conversationId, conversationMan
     skills: activatedSkills,
     threadId,
     threadPath,
-    metadataManager
+    metadataManager,
+    loadMcpTools: false
   });
   const promptSections = await loadPromptSections(
     threadPath,
@@ -10210,6 +10436,14 @@ async function deleteThread(db, id) {
     throw error;
   }
 }
+async function getThread(db, id) {
+  const result = await db.execute("SELECT * FROM threads WHERE id = ?", [id]);
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return deserializeThread(row);
+}
 async function getAllThreads(db) {
   try {
     const result = await db.execute(
@@ -12477,7 +12711,7 @@ var ProcessManager = class extends EventEmitter {
 
 // src/features/projects/projects.creator.ts
 init_utils();
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { basename as basename2, join as join20, relative as relative5 } from "path";
 import { access as access3, stat as stat3, readdir as readdir8 } from "fs/promises";
 
@@ -13663,14 +13897,14 @@ var ProjectCreator = class {
     }
     let initialThreadId;
     try {
-      const projectId = randomUUID7();
+      const projectId = randomUUID8();
       const existingProjects = await this.metadataManager.loadProjects();
       const existingNames = existingProjects.map((p) => p.name);
       const projectName = this.ensureUniqueProjectName(
         this.deriveProjectName(gitUrl),
         existingNames
       );
-      initialThreadId = randomUUID7();
+      initialThreadId = randomUUID8();
       const initialThreadTitle = generateRandomThreadName();
       const firstThreadPath = this.generateThreadPath(projectId, initialThreadId);
       this.processingStateManager?.setProcessing(initialThreadId);
@@ -13810,8 +14044,8 @@ var ProjectCreator = class {
       };
       return;
     }
-    const projectId = randomUUID7();
-    const initialThreadId = randomUUID7();
+    const projectId = randomUUID8();
+    const initialThreadId = randomUUID8();
     const initialThreadTitle = generateRandomThreadName();
     this.processingStateManager?.setProcessing(initialThreadId);
     try {
@@ -13961,8 +14195,8 @@ var ProjectCreator = class {
       yield { type: "error", message: `Cannot access folder: ${folderPath}` };
       return;
     }
-    const projectId = randomUUID7();
-    const initialThreadId = randomUUID7();
+    const projectId = randomUUID8();
+    const initialThreadId = randomUUID8();
     const initialThreadTitle = generateRandomThreadName();
     this.processingStateManager?.setProcessing(initialThreadId);
     try {
@@ -14396,7 +14630,7 @@ var ProjectManagerImpl = class {
       throw new Error(`Project not found: ${projectId}`);
     }
     if (setupScript === null || setupScript === "") {
-      delete projects[projectIndex].setupScript;
+      Reflect.set(projects[projectIndex], "setupScript", null);
     } else {
       projects[projectIndex].setupScript = setupScript;
     }
@@ -14414,7 +14648,7 @@ var ProjectManagerImpl = class {
       throw new Error(`Project not found: ${projectId}`);
     }
     if (validationScript === null || validationScript === "") {
-      delete projects[projectIndex].validationScript;
+      Reflect.set(projects[projectIndex], "validationScript", null);
     } else {
       projects[projectIndex].validationScript = validationScript;
     }
@@ -14536,11 +14770,15 @@ ___CWD___%s
    */
   async updateRunCommand(projectId, runCommand) {
     const projects = await this.metadataManager.loadProjects();
-    const project = projects.find((p) => p.id === projectId);
-    if (!project) {
+    const projectIndex = projects.findIndex((p) => p.id === projectId);
+    if (projectIndex === -1) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    project.runCommand = runCommand ?? void 0;
+    if (runCommand === null || runCommand === "") {
+      Reflect.set(projects[projectIndex], "runCommand", null);
+    } else {
+      projects[projectIndex].runCommand = runCommand;
+    }
     await this.metadataManager.saveProjects(projects);
   }
   /**
@@ -14569,7 +14807,7 @@ ___CWD___%s
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    project[field] = value && value.trim() ? value : void 0;
+    Reflect.set(project, field, value && value.trim() ? value : null);
     await this.metadataManager.saveProjects(projects);
   }
   /**
@@ -15946,7 +16184,7 @@ function createRuleRoutes(router, projectManager) {
 
 // src/features/threads/threads.manager.ts
 init_utils();
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { join as join23 } from "path";
 import { execSync as execSync3 } from "child_process";
 import { rm as rm4, stat as stat4, mkdir as mkdir4 } from "fs/promises";
@@ -16013,7 +16251,7 @@ var ThreadManagerImpl = class {
       } catch {
         await mkdir4(project.path, { recursive: true });
       }
-      threadId = randomUUID8();
+      threadId = randomUUID9();
       const threadPath = this.generateThreadPath(projectId, threadId);
       const existingThreads = await this.metadataManager.loadThreads();
       const existingTitles = new Set(
@@ -16554,7 +16792,7 @@ import { glob as glob2 } from "glob";
 
 // src/features/project-scripts/project-scripts.database.ts
 init_database();
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 async function getScriptsByProject(db, projectId) {
   const result = await db.execute({
     sql: `SELECT id, projectId, workspace, name, command, friendlyName, updatedAt
@@ -16571,7 +16809,7 @@ async function upsertProjectScripts(projectId, scripts) {
       sql: `INSERT OR REPLACE INTO project_scripts (id, projectId, workspace, name, command, friendlyName, updatedAt)
             VALUES (?, ?, ?, ?, ?, ?, ?)`,
       args: [
-        randomUUID9(),
+        randomUUID10(),
         projectId,
         script.workspace,
         script.name,
@@ -17078,7 +17316,8 @@ async function handleGetThreadMessages(c, threadManager, conversationManager) {
           fileName: attachment.name,
           content: attachment.content,
           size: attachment.size
-        }))
+        })),
+        checkpointRef: message.request.checkpointRef
       };
       if (!message.response) {
         return [userMessage];
@@ -18652,6 +18891,101 @@ import { existsSync as existsSync18 } from "fs";
 
 // src/features/git/git.utils.ts
 init_utils();
+
+// src/features/git/git-subprocess-timing.ts
+init_utils();
+import { AsyncLocalStorage } from "async_hooks";
+var GITOPS_TIMING_PREFIX = "[gitops-timing]";
+var timingStorage = new AsyncLocalStorage();
+function withGitTimingContext(threadId, fn) {
+  return timingStorage.run({ threadId }, fn);
+}
+function isGitSubprocessTimingEnabled() {
+  return timingStorage.getStore() !== void 0;
+}
+function logSubprocessMark(scope, stepName, label, offsetMs) {
+  console.log(
+    `${GITOPS_TIMING_PREFIX} subprocess ${scope} step=${stepName} ${label} +${offsetMs}ms`
+  );
+}
+function runCommandTimed(stepName, command, args2, cwd) {
+  const scope = `thread=${timingStorage.getStore()?.threadId ?? "unknown"}`;
+  const t0 = Date.now();
+  let tSpawnEvent = null;
+  let tFirstIo = null;
+  let tExit = null;
+  logSubprocessMark(scope, stepName, "spawn-call", 0);
+  return new Promise((resolve6, reject) => {
+    const proc = spawnProcess(command, args2, { cwd });
+    proc.on("spawn", () => {
+      tSpawnEvent = Date.now();
+      logSubprocessMark(scope, stepName, "spawn-event", tSpawnEvent - t0);
+    });
+    let stdout = "";
+    let stderr = "";
+    function onIo() {
+      if (tFirstIo === null) {
+        tFirstIo = Date.now();
+        logSubprocessMark(scope, stepName, "first-io", tFirstIo - t0);
+      }
+    }
+    if (proc.stdout) {
+      proc.stdout.on("data", (chunk) => {
+        onIo();
+        stdout += chunk.toString();
+      });
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (chunk) => {
+        onIo();
+        stderr += chunk.toString();
+      });
+    }
+    proc.on("exit", () => {
+      tExit = Date.now();
+      logSubprocessMark(scope, stepName, "process-exit", tExit - t0);
+    });
+    proc.on("close", (code) => {
+      const tClose = Date.now();
+      logSubprocessMark(scope, stepName, "close-callback", tClose - t0);
+      const preSpawnMs = tSpawnEvent !== null ? tSpawnEvent - t0 : null;
+      const processActiveMs = tSpawnEvent !== null && tExit !== null ? tExit - tSpawnEvent : null;
+      const exitToCloseMs = tExit !== null ? tClose - tExit : null;
+      console.log(
+        `${GITOPS_TIMING_PREFIX} subprocess ${scope} step=${stepName} summary total=${tClose - t0}ms` + (preSpawnMs !== null ? ` pre-spawn=${preSpawnMs}ms` : "") + (processActiveMs !== null ? ` process-active=${processActiveMs}ms` : "") + (exitToCloseMs !== null ? ` exit-to-close=${exitToCloseMs}ms` : "") + ` cmd=${command} ${args2.join(" ")}`
+      );
+      resolve6({ code, stdout, stderr });
+    });
+    proc.on("error", (error) => {
+      logSubprocessMark(scope, stepName, "spawn-error", Date.now() - t0);
+      reject(error);
+    });
+  });
+}
+function runGitCommandTimed(stepName, cwd, args2) {
+  return runCommandTimed(stepName, "git", args2, cwd);
+}
+var EVENT_LOOP_LAG_THRESHOLD_MS = 50;
+var EVENT_LOOP_SAMPLE_INTERVAL_MS = 100;
+function startEventLoopLagMonitor(threadId) {
+  const requestStart = Date.now();
+  let expectedAt = requestStart + EVENT_LOOP_SAMPLE_INTERVAL_MS;
+  const intervalId = setInterval(() => {
+    const now = Date.now();
+    const lag = now - expectedAt;
+    if (lag >= EVENT_LOOP_LAG_THRESHOLD_MS) {
+      console.log(
+        `${GITOPS_TIMING_PREFIX} event-loop-lag thread=${threadId} lag=${lag}ms at=+${now - requestStart}ms`
+      );
+    }
+    expectedAt = now + EVENT_LOOP_SAMPLE_INTERVAL_MS;
+  }, EVENT_LOOP_SAMPLE_INTERVAL_MS);
+  return () => {
+    clearInterval(intervalId);
+  };
+}
+
+// src/features/git/git.utils.ts
 import { existsSync as existsSync17, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolve3, join as join28 } from "path";
 import { completeSimple } from "@mariozechner/pi-ai";
@@ -18796,32 +19130,61 @@ function resolveThreadPath(repoPath) {
   const base = isAbsolute3(repoPath) ? repoPath : resolve3(getDataDir(), repoPath);
   return normalize2(base);
 }
-function getGitRoot(cwd) {
-  return new Promise((resolveRoot, reject) => {
-    const proc = spawnProcess("git", ["rev-parse", "--show-toplevel"], { cwd });
-    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();
-      });
+var gitRootCache = /* @__PURE__ */ new Map();
+async function getGitRoot(cwd) {
+  const cacheKey = normalize2(cwd);
+  const cached = gitRootCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  let gitRoot;
+  if (isGitSubprocessTimingEnabled()) {
+    const result = await runGitCommandTimed("resolve-git-root", cwd, [
+      "rev-parse",
+      "--show-toplevel"
+    ]);
+    if (result.code === 0) {
+      gitRoot = result.stdout.trim();
+    } else {
+      throw new Error(result.stderr.trim() || "Not a git repository");
     }
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolveRoot(out.trim());
-      } else {
-        reject(new Error(err.trim() || "Not a git repository"));
+  } else {
+    gitRoot = await new Promise((resolveRoot, reject) => {
+      const proc = spawnProcess("git", ["rev-parse", "--show-toplevel"], { cwd });
+      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) {
+          resolveRoot(out.trim());
+        } else {
+          reject(new Error(err.trim() || "Not a git repository"));
+        }
+      });
+      proc.on("error", reject);
     });
-    proc.on("error", reject);
-  });
+  }
+  gitRootCache.set(cacheKey, gitRoot);
+  return gitRoot;
 }
-function getCurrentBranch(gitRoot) {
+async function getCurrentBranch(gitRoot) {
+  if (isGitSubprocessTimingEnabled()) {
+    const result = await runGitCommandTimed("getCurrentBranch", gitRoot, [
+      "rev-parse",
+      "--abbrev-ref",
+      "HEAD"
+    ]);
+    return result.stdout.trim();
+  }
   return new Promise((resolve6) => {
     const proc = spawnProcess("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: gitRoot });
     let out = "";
@@ -18934,7 +19297,15 @@ new file mode 100644
   }
   return parts.join("\n");
 }
-function getGitStatus(gitRoot) {
+async function getGitStatus(gitRoot) {
+  if (isGitSubprocessTimingEnabled()) {
+    const result = await runGitCommandTimed("getGitStatus", gitRoot, [
+      "status",
+      "--porcelain",
+      "--untracked-files=all"
+    ]);
+    return result.stdout;
+  }
   return new Promise((resolve6) => {
     const proc = spawnProcess("git", ["status", "--porcelain", "--untracked-files=all"], {
       cwd: gitRoot
@@ -18987,7 +19358,18 @@ function hasCommitsAheadOfDefault(gitRoot, defaultBranch) {
     proc.on("error", () => resolve6(false));
   });
 }
-function getRemoteOrigin(gitRoot) {
+async function getRemoteOrigin(gitRoot) {
+  if (isGitSubprocessTimingEnabled()) {
+    const result = await runGitCommandTimed("getRemoteOrigin", gitRoot, [
+      "remote",
+      "get-url",
+      "origin"
+    ]);
+    if (result.code === 0) {
+      return result.stdout.trim();
+    }
+    return "";
+  }
   return new Promise((resolve6) => {
     const proc = spawnProcess("git", ["remote", "get-url", "origin"], { cwd: gitRoot });
     let out = "";
@@ -19006,54 +19388,22 @@ function getRemoteOrigin(gitRoot) {
     proc.on("error", () => resolve6(""));
   });
 }
-async function getGitSyncStatus(gitRoot, branch) {
+async function getGitSyncStatus(gitRoot, branch, options) {
+  const fetchRemote = options?.fetchRemote ?? false;
   console.log(`[git-status] Checking sync status for branch: ${branch}`);
-  console.log(`[git-status] Fetching from origin...`);
-  await new Promise((resolve6) => {
-    const fetchProc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
-    fetchProc.on("close", () => {
-      console.log(`[git-status] \u2713 Fetch completed`);
-      resolve6();
-    });
-    fetchProc.on("error", () => {
-      console.log(`[git-status] Fetch error (continuing anyway)`);
-      resolve6();
-    });
-  });
-  console.log(`[git-status] Finding default branch...`);
-  const defaultBranch = await findDefaultBranch(gitRoot);
-  console.log(`[git-status] Default branch: ${defaultBranch}`);
-  if (defaultBranch && defaultBranch !== branch) {
-    console.log(`[git-status] Checking if ${branch} is behind ${defaultBranch}...`);
-    const isBehindDefault = await new Promise((resolve6) => {
-      const proc = spawnProcess(
-        "git",
-        ["rev-list", "--count", `${branch}..origin/${defaultBranch}`],
-        { cwd: gitRoot }
-      );
-      let out = "";
-      if (proc.stdout) {
-        proc.stdout.on("data", (d) => {
-          out += d.toString();
-        });
-      }
-      proc.on("close", () => {
-        const count = parseInt(out.trim(), 10);
-        console.log(`[git-status] Commits in ${defaultBranch} but not in ${branch}: ${count}`);
-        resolve6(count > 0);
+  if (fetchRemote) {
+    console.log(`[git-status] Fetching from origin...`);
+    await new Promise((resolve6) => {
+      const fetchProc = spawnProcess("git", ["fetch", "origin"], { cwd: gitRoot });
+      fetchProc.on("close", () => {
+        console.log(`[git-status] \u2713 Fetch completed`);
+        resolve6();
       });
-      proc.on("error", () => {
-        console.log(`[git-status] Error checking commits (assuming not behind)`);
-        resolve6(false);
+      fetchProc.on("error", () => {
+        console.log(`[git-status] Fetch error (continuing anyway)`);
+        resolve6();
       });
     });
-    if (isBehindDefault) {
-      console.log(`[git-status] \u2713 Branch IS behind default branch`);
-      return "Behind";
-    }
-    console.log(`[git-status] Branch is NOT behind default branch`);
-  } else {
-    console.log(`[git-status] Skipping default branch check (same branch or no default found)`);
   }
   console.log(`[git-status] Checking status against remote tracking branch...`);
   return new Promise((resolve6) => {
@@ -19071,27 +19421,30 @@ async function getGitSyncStatus(gitRoot, branch) {
       });
     }
     statusProc.on("close", () => {
-      const output = statusOut + statusErr;
-      console.log(`[git-status] git status -sb output: ${output.trim()}`);
-      if (!output.includes(branch)) {
+      const output = (statusOut + statusErr).trim();
+      console.log(`[git-status] git status -sb output: ${output}`);
+      const firstLine = output.split("\n")[0] ?? "";
+      if (!firstLine.includes(branch)) {
         console.log(`[git-status] Branch name not found in status output, returning 'Up to date'`);
         resolve6("Up to date");
         return;
       }
-      if (output.includes("ahead") && output.includes("behind")) {
+      if (!firstLine.includes("...")) {
+        console.log(`[git-status] No upstream tracking branch detected, returning 'Up to date'`);
+        resolve6("Up to date");
+        return;
+      }
+      if (firstLine.includes("ahead") && firstLine.includes("behind")) {
         console.log(`[git-status] \u2713 Status: Diverged`);
         resolve6("Diverged");
-      } else if (output.includes("behind")) {
+      } else if (firstLine.includes("behind")) {
         console.log(`[git-status] \u2713 Status: Behind`);
         resolve6("Behind");
-      } else if (output.includes("ahead")) {
+      } else if (firstLine.includes("ahead")) {
         console.log(`[git-status] \u2713 Status: Ahead`);
         resolve6("Ahead");
-      } else if (output.includes("#") && !output.includes("ahead") && !output.includes("behind")) {
-        console.log(`[git-status] \u2713 Status: Up to date`);
-        resolve6("Up to date");
       } else {
-        console.log(`[git-status] \u2713 Status: Up to date (default)`);
+        console.log(`[git-status] \u2713 Status: Up to date`);
         resolve6("Up to date");
       }
     });
@@ -19137,18 +19490,13 @@ function getDefaultBranch(gitRoot) {
   });
 }
 async function findDefaultBranch(gitRoot) {
+  const fromOriginHead = await getDefaultBranch(gitRoot);
+  if (fromOriginHead) return fromOriginHead;
   const candidates = ["main", "master", "develop", "staging"];
-  for (const branch of candidates) {
-    const exists = await new Promise((resolve6) => {
-      const proc = spawnProcess("git", ["rev-parse", "--verify", `origin/${branch}`], {
-        cwd: gitRoot
-      });
-      proc.on("close", (code) => resolve6(code === 0));
-      proc.on("error", () => resolve6(false));
-    });
-    if (exists) return branch;
-  }
-  return null;
+  const checks = await Promise.all(
+    candidates.map(async (branch) => await hasRemoteBranch(gitRoot, branch) ? branch : null)
+  );
+  return checks.find((branch) => branch !== null) ?? null;
 }
 function getCommitLog(gitRoot, baseBranch, currentBranch) {
   return new Promise((resolve6) => {
@@ -19394,7 +19742,31 @@ function createPullRequest(gitRoot, title, description) {
     });
   });
 }
-function getPullRequestStatus(gitRoot) {
+async function getPullRequestStatus(gitRoot) {
+  if (isGitSubprocessTimingEnabled()) {
+    const result = await runCommandTimed(
+      "getPullRequestStatus",
+      "gh",
+      ["pr", "view", "--json", "url,state"],
+      gitRoot
+    );
+    if (result.code === 0) {
+      try {
+        const prData = JSON.parse(result.stdout.trim());
+        return {
+          exists: true,
+          url: prData.url,
+          state: prData.state
+        };
+      } catch {
+        throw new Error("Failed to parse PR data");
+      }
+    }
+    if (result.stderr.includes("no pull requests") || result.stderr.includes("not found")) {
+      return { exists: false };
+    }
+    throw new Error(result.stderr || "Failed to check PR status");
+  }
   return new Promise((resolve6, reject) => {
     const args2 = ["pr", "view", "--json", "url,state"];
     const proc = spawnProcess("gh", args2, { cwd: gitRoot });
@@ -20160,7 +20532,60 @@ async function gitGithubStatusHandler(c, metadataManager) {
 
 // src/features/git/git-unified-status.route.ts
 import { existsSync as existsSync20 } from "fs";
-async function gitUnifiedStatusHandler(c, metadataManager, db) {
+function parseChangedFiles(statusOutput) {
+  const lines = statusOutput.trim().split("\n").filter((line) => line.length > 0);
+  return {
+    hasChanges: lines.length > 0,
+    changedFilesCount: lines.length
+  };
+}
+function buildRepoUrl(remoteUrl, isOnGitHub) {
+  if (!isOnGitHub) return "";
+  if (remoteUrl.startsWith("https://")) {
+    return remoteUrl.replace(/\.git$/, "");
+  }
+  if (remoteUrl.startsWith("git@")) {
+    const match = remoteUrl.match(/git@github\.com:(.+?)\.git$/);
+    if (match) {
+      return `https://github.com/${match[1]}`;
+    }
+  }
+  return "";
+}
+function createServerStepTracker(threadId) {
+  const steps = [];
+  const requestStart = Date.now();
+  async function step(name, fn) {
+    const start = Date.now();
+    try {
+      return await fn();
+    } finally {
+      const ms = Date.now() - start;
+      steps.push({ step: name, ms });
+      console.log(`[gitops-timing] unified-status thread=${threadId} step=${name} ${ms}ms`);
+    }
+  }
+  function record(name, start, extra) {
+    const ms = Date.now() - start;
+    steps.push({ step: name, ms });
+    console.log(
+      `[gitops-timing] unified-status thread=${threadId} step=${name} ${ms}ms${extra ? ` ${extra}` : ""}`
+    );
+  }
+  function summary(extra) {
+    const total = Date.now() - requestStart;
+    const slowest = steps.reduce((best, current) => current.ms >= best.ms ? current : best, {
+      step: "none",
+      ms: 0
+    });
+    const breakdown = steps.map((s) => `${s.step}:${s.ms}`).join(" ");
+    console.log(
+      `[gitops-timing] unified-status thread=${threadId} summary total=${total}ms slowest=${slowest.step}@${slowest.ms}ms breakdown=[${breakdown}]${extra ? ` ${extra}` : ""}`
+    );
+  }
+  return { step, record, summary };
+}
+async function gitUnifiedStatusHandler(c, _metadataManager, db) {
   try {
     const threadId = c.req.param("threadId");
     if (!threadId) {
@@ -20172,138 +20597,111 @@ async function gitUnifiedStatusHandler(c, metadataManager, db) {
       return c.json(response, statusCode);
     }
     const fresh = c.req.query("fresh") === "true";
+    const tracker = createServerStepTracker(threadId);
     if (!fresh) {
+      const cacheStart = Date.now();
       const cached = await getGitStatusCache(db, threadId);
+      tracker.record("db-cache-read", cacheStart, `hit=${cached ? "true" : "false"}`);
       if (cached) {
+        tracker.summary("cached=true");
         return c.json({ ...cached, cached: true });
       }
     }
-    const thread = await metadataManager.loadThreads().then((threads) => threads.find((t) => t.id === threadId));
-    if (!thread) {
-      return c.json({ error: "Thread not found" }, 404);
-    }
-    const repoPath = thread.path;
-    if (!repoPath) {
-      return c.json({ error: "Thread path not found" }, 404);
-    }
-    const absolutePath = resolveThreadPath(repoPath);
-    if (!existsSync20(absolutePath)) {
-      return c.json(
-        {
-          error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
-        },
-        400
-      );
-    }
-    let gitRoot;
-    try {
-      gitRoot = await getGitRoot(absolutePath);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return c.json(
-        {
-          error: `Path is not a git repository: ${absolutePath}. ${msg}`
-        },
-        400
-      );
-    }
-    const { hasChanges, changedFilesCount } = await new Promise((resolve6) => {
-      getGitStatus(gitRoot).then((statusOutput) => {
-        const lines = statusOutput.trim().split("\n").filter((line) => line.length > 0);
-        resolve6({
-          hasChanges: lines.length > 0,
-          changedFilesCount: lines.length
-        });
-      }).catch(() => resolve6({ hasChanges: false, changedFilesCount: 0 }));
-    });
-    const currentBranch = await getCurrentBranch(gitRoot);
-    const hasUnpushed = await hasUnpushedCommits(gitRoot, currentBranch);
-    const remoteUrl = await getRemoteOrigin(gitRoot);
-    const isOnGitHub = remoteUrl.includes("github.com");
-    let repoUrl = "";
-    if (isOnGitHub) {
-      if (remoteUrl.startsWith("https://")) {
-        repoUrl = remoteUrl.replace(/\.git$/, "");
-      } else if (remoteUrl.startsWith("git@")) {
-        const match = remoteUrl.match(/git@github\.com:(.+?)\.git$/);
-        if (match) {
-          repoUrl = `https://github.com/${match[1]}`;
-        }
-      }
-    }
-    let hasRemoteBranchExists = false;
-    if (remoteUrl && currentBranch && currentBranch !== "HEAD") {
-      try {
-        hasRemoteBranchExists = await hasRemoteBranch(gitRoot, currentBranch);
-      } catch (error) {
-        console.warn(
-          `Failed to check remote branch existence: ${error instanceof Error ? error.message : String(error)}`
-        );
-        hasRemoteBranchExists = false;
-      }
-    }
-    let defaultBranchName = null;
-    try {
-      defaultBranchName = await findDefaultBranch(gitRoot);
-    } catch (error) {
-      console.warn(
-        `Failed to find default branch: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    let commitsAheadOfDefault = false;
-    if (defaultBranchName && currentBranch && currentBranch !== defaultBranchName) {
-      try {
-        commitsAheadOfDefault = await hasCommitsAheadOfDefault(gitRoot, defaultBranchName);
-      } catch {
-        commitsAheadOfDefault = false;
-      }
-    }
-    let status = "Up to date";
-    if (isOnGitHub && remoteUrl) {
+    return withGitTimingContext(threadId, async () => {
+      const stopLagMonitor = startEventLoopLagMonitor(threadId);
       try {
-        if (currentBranch && currentBranch !== "HEAD") {
-          status = await getGitSyncStatus(gitRoot, currentBranch);
+        const thread = await tracker.step("thread-lookup", () => getThread(db, threadId));
+        if (!thread) {
+          tracker.summary("error=thread-not-found");
+          return c.json({ error: "Thread not found" }, 404);
         }
-      } catch (error) {
-        console.warn(
-          `Failed to check git sync status: ${error instanceof Error ? error.message : String(error)}`
-        );
-        status = "Up to date";
-      }
-    }
-    let prStatus = { exists: false };
-    if (isOnGitHub) {
-      try {
-        prStatus = await getPullRequestStatus(gitRoot);
-      } catch (error) {
-        console.warn(
-          `Failed to check PR status: ${error instanceof Error ? error.message : String(error)}`
+        const repoPath = thread.path;
+        if (!repoPath) {
+          tracker.summary("error=thread-path-missing");
+          return c.json({ error: "Thread path not found" }, 404);
+        }
+        const absolutePath = resolveThreadPath(repoPath);
+        if (!existsSync20(absolutePath)) {
+          tracker.summary("error=repo-path-missing");
+          return c.json(
+            {
+              error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`
+            },
+            400
+          );
+        }
+        let gitRoot;
+        try {
+          gitRoot = await tracker.step("resolve-git-root", () => getGitRoot(absolutePath));
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          tracker.summary("error=not-git-repo");
+          return c.json(
+            {
+              error: `Path is not a git repository: ${absolutePath}. ${msg}`
+            },
+            400
+          );
+        }
+        const [statusOutput, currentBranch, remoteUrl] = await Promise.all([
+          tracker.step("getGitStatus", () => getGitStatus(gitRoot).catch(() => "")),
+          tracker.step("getCurrentBranch", () => getCurrentBranch(gitRoot)),
+          tracker.step("getRemoteOrigin", () => getRemoteOrigin(gitRoot))
+        ]);
+        const { hasChanges, changedFilesCount } = parseChangedFiles(statusOutput);
+        const isOnGitHub = remoteUrl.includes("github.com");
+        const repoUrl = buildRepoUrl(remoteUrl, isOnGitHub);
+        const [hasUnpushed, hasRemoteBranchExists, defaultBranchName] = await Promise.all([
+          tracker.step("hasUnpushedCommits", () => hasUnpushedCommits(gitRoot, currentBranch)),
+          remoteUrl && currentBranch && currentBranch !== "HEAD" ? tracker.step(
+            "hasRemoteBranch",
+            () => hasRemoteBranch(gitRoot, currentBranch).catch(() => false)
+          ) : Promise.resolve(false),
+          tracker.step("findDefaultBranch", () => findDefaultBranch(gitRoot).catch(() => null))
+        ]);
+        const emptyPrStatus = { exists: false };
+        const [commitsAheadOfDefault, status, prStatus] = await Promise.all([
+          defaultBranchName && currentBranch && currentBranch !== defaultBranchName ? tracker.step(
+            "hasCommitsAheadOfDefault",
+            () => hasCommitsAheadOfDefault(gitRoot, defaultBranchName).catch(() => false)
+          ) : Promise.resolve(false),
+          isOnGitHub && remoteUrl && currentBranch && currentBranch !== "HEAD" ? tracker.step(
+            "getGitSyncStatus",
+            () => getGitSyncStatus(gitRoot, currentBranch, { fetchRemote: fresh }).catch(
+              () => "Up to date"
+            )
+          ) : Promise.resolve("Up to date"),
+          isOnGitHub ? tracker.step(
+            "getPullRequestStatus",
+            () => getPullRequestStatus(gitRoot).catch(() => emptyPrStatus)
+          ) : Promise.resolve(emptyPrStatus)
+        ]);
+        const result = {
+          hasChanges,
+          changedFilesCount,
+          currentBranch,
+          hasUnpushedCommits: hasUnpushed,
+          hasRemoteBranch: hasRemoteBranchExists,
+          commitsAheadOfDefault,
+          isOnGitHub,
+          remoteUrl,
+          canCreateRepo: !isOnGitHub && remoteUrl.length === 0,
+          repoUrl,
+          status,
+          defaultBranch: defaultBranchName,
+          prExists: prStatus.exists,
+          prUrl: prStatus.url,
+          prState: prStatus.state
+        };
+        await tracker.step("db-cache-write", () => setGitStatusCache(db, threadId, result));
+        tracker.summary(
+          `cached=false branch=${currentBranch || "none"} changes=${changedFilesCount} prExists=${prStatus.exists} fresh=${fresh}`
         );
-        prStatus = { exists: false };
+        return c.json({ ...result, cached: false });
+      } finally {
+        stopLagMonitor();
       }
-    }
-    const result = {
-      // Git status fields
-      hasChanges,
-      changedFilesCount,
-      currentBranch,
-      hasUnpushedCommits: hasUnpushed,
-      hasRemoteBranch: hasRemoteBranchExists,
-      commitsAheadOfDefault,
-      // GitHub status fields
-      isOnGitHub,
-      remoteUrl,
-      canCreateRepo: !isOnGitHub && remoteUrl.length === 0,
-      repoUrl,
-      status,
-      defaultBranch: defaultBranchName,
-      // PR status fields
-      prExists: prStatus.exists,
-      prUrl: prStatus.url,
-      prState: prStatus.state
-    };
-    await setGitStatusCache(db, threadId, result);
-    return c.json({ ...result, cached: false });
+    });
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to get unified git status";
     return c.json({ error: message }, 500);
@@ -22197,12 +22595,23 @@ function createBrowserJsRoutes(threadManager) {
 
 // src/features/voice-model/voice-model.routes.ts
 import { Hono as Hono21 } from "hono";
-var MODEL_URL = "https://install.tarsk.io/voice-models/ggml-tiny.en.bin";
+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;
+}
 function createVoiceModelRoutes() {
   const router = new Hono21();
   router.get("/download", async (c) => {
+    const selectedModel = c.req.query("model");
+    const modelUrl = getVoiceModelUrl(selectedModel);
     try {
-      const response = await fetch(MODEL_URL);
+      const response = await fetch(modelUrl);
       if (!response.ok) {
         return errorResponse(
           c,
@@ -22213,7 +22622,8 @@ function createVoiceModelRoutes() {
       }
       const contentLength = response.headers.get("content-length");
       const headers = {
-        "Content-Type": "application/octet-stream"
+        "Content-Type": "application/octet-stream",
+        "X-Tarsk-Voice-Model": selectedModel === "tiny" ? "tiny" : "default"
       };
       if (contentLength) {
         headers["Content-Length"] = contentLength;
@@ -22275,13 +22685,82 @@ function createLogsRoutes() {
   return router;
 }
 
+// src/features/user-tasks/user-tasks.routes.ts
+init_database();
+import { Hono as Hono23 } from "hono";
+
+// src/features/user-tasks/user-tasks.database.ts
+init_database();
+import { randomUUID as randomUUID11 } from "crypto";
+async function getUserTasksByThread(db, threadId) {
+  const result = await db.execute({
+    sql: `SELECT id, threadId, content, createdAt, updatedAt
+          FROM user_tasks
+          WHERE threadId = ?
+          ORDER BY createdAt ASC`,
+    args: [threadId]
+  });
+  return result.rows;
+}
+async function insertUserTask(threadId, content) {
+  const db = await getDatabase();
+  const id = randomUUID11();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO user_tasks (id, threadId, content, createdAt, updatedAt)
+          VALUES (?, ?, ?, ?, ?)`,
+    args: [id, threadId, content, now, now]
+  });
+  return {
+    id,
+    threadId,
+    content,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function deleteUserTaskById(db, id) {
+  await db.execute({
+    sql: `DELETE FROM user_tasks WHERE id = ?`,
+    args: [id]
+  });
+}
+
+// src/features/user-tasks/user-tasks.routes.ts
+function createUserTaskRoutes() {
+  const router = new Hono23();
+  router.get("/:threadId/user-tasks", async (c) => {
+    const threadId = c.req.param("threadId");
+    const db = await getDatabase();
+    const tasks = await getUserTasksByThread(db, threadId);
+    return c.json({ tasks });
+  });
+  router.post("/:threadId/user-tasks", async (c) => {
+    const threadId = c.req.param("threadId");
+    const body = await c.req.json();
+    const content = body.content?.trim();
+    if (!content) {
+      return c.json({ error: "content is required" }, 400);
+    }
+    const task = await insertUserTask(threadId, content);
+    return c.json(task, 201);
+  });
+  router.delete("/:threadId/user-tasks/:taskId", async (c) => {
+    const taskId = c.req.param("taskId");
+    const db = await getDatabase();
+    await deleteUserTaskById(db, taskId);
+    return c.json({ success: true });
+  });
+  return router;
+}
+
 // src/server.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path4.dirname(__filename);
 async function startTarskServer(options) {
   const { isDebug: isDebug2, publicDir: publicDirOverride } = options;
   const port = isDebug2 ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
-  const app = new Hono23();
+  const app = new Hono24();
   app.use("/*", cors());
   app.use("/*", async (c, next) => {
     c.header("Cross-Origin-Opener-Policy", "same-origin");
@@ -22341,6 +22820,7 @@ async function startTarskServer(options) {
   app.route("/api/projects", createRunRoutes(projectManager));
   app.route("/api/projects", createProjectTodosRoutes(metadataManager));
   app.route("/api/threads", createThreadRoutes(threadManager, gitManager, conversationManager));
+  app.route("/api/threads", createUserTaskRoutes());
   app.route(
     "/api/chat",
     createChatRoutes(threadManager, agentExecutor, conversationManager, processingStateManager)
@@ -22376,19 +22856,18 @@ async function startTarskServer(options) {
       `No static frontend assets found. Expected one of: ${prodPublicDir}, ${devCopiedPublicDir}, ${appDistDir}. Build the app first with \`cd ../app && bun run build\`.`
     );
   }
-  const staticRoot = path4.relative(process.cwd(), resolvedPublicDir);
   app.use("/*", async (c, next) => {
     if (c.req.path.startsWith("/api/")) {
       return next();
     }
-    return serveStatic({ root: staticRoot })(c, next);
+    return serveStatic({ root: resolvedPublicDir })(c, next);
   });
   app.get("*", async (c, next) => {
     if (c.req.path.startsWith("/api/")) {
       return next();
     }
     return serveStatic({
-      path: path4.relative(process.cwd(), path4.join(resolvedPublicDir, "index.html"))
+      path: path4.join(resolvedPublicDir, "index.html")
     })(c, next);
   });
   app.all("*", (c) => {