assistme 0.3.2 → 0.3.4

package/dist/index.js

@@ -171,22 +171,36 @@ async function getConversationHistory(conversationId, excludeMessageId, limit =
 }
 
 // src/db/event.ts
+var MAX_EMIT_RETRIES = 2;
+var EMIT_RETRY_DELAY_MS = 500;
+async function emitWithRetry(messageId, eventType, eventData, seq) {
+  for (let attempt = 0; attempt <= MAX_EMIT_RETRIES; attempt++) {
+    try {
+      await callMcpHandler("event.emit", {
+        message_id: messageId,
+        event_type: eventType,
+        event_data: eventData,
+        seq
+      });
+      return;
+    } catch (err) {
+      if (attempt < MAX_EMIT_RETRIES) {
+        await new Promise((r) => setTimeout(r, EMIT_RETRY_DELAY_MS * (attempt + 1)));
+      } else {
+        log.warn(
+          `Failed to emit event after ${MAX_EMIT_RETRIES + 1} attempts: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+  }
+}
 var eventSequence = 0;
 function resetEventSequence() {
   eventSequence = 0;
 }
 async function emitEvent(messageId, eventType, eventData) {
   eventSequence++;
-  try {
-    await callMcpHandler("event.emit", {
-      message_id: messageId,
-      event_type: eventType,
-      event_data: eventData,
-      seq: eventSequence
-    });
-  } catch (err) {
-    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-  }
+  await emitWithRetry(messageId, eventType, eventData, eventSequence);
 }
 
 // src/db/action.ts
@@ -493,11 +507,20 @@ URL: ${info.url}`;
   }
   async goBack() {
     this.ensureConnected();
-    await this.send("Page.navigateToHistoryEntry", {
-      entryId: -1
-    }).catch(() => {
-    });
-    await this.evaluate("window.history.back()");
+    try {
+      const history = await this.send("Page.getNavigationHistory");
+      const idx = history.currentIndex ?? 0;
+      const entries = history.entries ?? [];
+      if (idx > 0 && entries[idx - 1]) {
+        await this.send("Page.navigateToHistoryEntry", {
+          entryId: entries[idx - 1].id
+        });
+      } else {
+        await this.evaluate("window.history.back()");
+      }
+    } catch {
+      await this.evaluate("window.history.back()");
+    }
     await this.waitForLoad();
     const info = await this.getPageInfo();
     return `Went back to: ${info.title}`;
@@ -665,29 +688,80 @@ URL: ${info.url}`;
       Tab: { keyCode: 9, code: "Tab" },
       Escape: { keyCode: 27, code: "Escape" },
       Backspace: { keyCode: 8, code: "Backspace" },
+      Delete: { keyCode: 46, code: "Delete" },
       ArrowDown: { keyCode: 40, code: "ArrowDown" },
-      ArrowUp: { keyCode: 38, code: "ArrowUp" }
+      ArrowUp: { keyCode: 38, code: "ArrowUp" },
+      ArrowLeft: { keyCode: 37, code: "ArrowLeft" },
+      ArrowRight: { keyCode: 39, code: "ArrowRight" },
+      Home: { keyCode: 36, code: "Home" },
+      End: { keyCode: 35, code: "End" },
+      Space: { keyCode: 32, code: "Space" }
+    };
+    const modifierMap = {
+      Alt: 1,
+      Control: 2,
+      Meta: 4,
+      Shift: 8
     };
-    const mapped = keyMap[key];
+    const parts = key.split("+");
+    let modifiers = 0;
+    let actualKey = parts[parts.length - 1];
+    for (let i = 0; i < parts.length - 1; i++) {
+      const mod = modifierMap[parts[i]];
+      if (mod) modifiers |= mod;
+    }
+    const mapped = keyMap[actualKey];
     if (mapped) {
       await this.send("Input.dispatchKeyEvent", {
         type: "keyDown",
-        key,
+        key: actualKey,
         code: mapped.code,
         windowsVirtualKeyCode: mapped.keyCode,
-        nativeVirtualKeyCode: mapped.keyCode
+        nativeVirtualKeyCode: mapped.keyCode,
+        modifiers
       });
       await this.send("Input.dispatchKeyEvent", {
         type: "keyUp",
-        key,
+        key: actualKey,
         code: mapped.code,
         windowsVirtualKeyCode: mapped.keyCode,
-        nativeVirtualKeyCode: mapped.keyCode
+        nativeVirtualKeyCode: mapped.keyCode,
+        modifiers
+      });
+    } else if (actualKey.length === 1) {
+      const code = `Key${actualKey.toUpperCase()}`;
+      const keyCode = actualKey.toUpperCase().charCodeAt(0);
+      await this.send("Input.dispatchKeyEvent", {
+        type: "keyDown",
+        key: actualKey,
+        code,
+        windowsVirtualKeyCode: keyCode,
+        nativeVirtualKeyCode: keyCode,
+        modifiers
+      });
+      if (!modifiers) {
+        await this.send("Input.dispatchKeyEvent", {
+          type: "char",
+          text: actualKey,
+          modifiers
+        });
+      }
+      await this.send("Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key: actualKey,
+        code,
+        modifiers
       });
     } else {
       await this.send("Input.dispatchKeyEvent", {
-        type: "char",
-        text: key
+        type: "keyDown",
+        key: actualKey,
+        modifiers
+      });
+      await this.send("Input.dispatchKeyEvent", {
+        type: "keyUp",
+        key: actualKey,
+        modifiers
       });
     }
     return `Pressed key: ${key}`;
@@ -1061,12 +1135,17 @@ Refs:
    */
   async clickRef(refId) {
     this.ensureConnected();
+    const ref = this.refCache.get(refId);
+    const refLabel = `[${refId}] ${ref?.role || ""} "${ref?.name || ""}"`;
     const maxRetries = 3;
     let lastError = "";
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       const resolved = await this.resolveRef(refId);
       if (!resolved) {
-        return `Ref [${refId}] not found. Take a new snapshot with browser_snapshot.`;
+        return {
+          success: false,
+          message: `Ref ${refLabel} not found. Take a new snapshot with browser_snapshot.`
+        };
       }
       if (resolved.error) {
         lastError = resolved.error;
@@ -1074,8 +1153,7 @@ Refs:
           await new Promise((r) => setTimeout(r, 500));
           continue;
         }
-        const ref3 = this.refCache.get(refId);
-        return `Cannot click [${refId}] ${ref3?.role || ""} "${ref3?.name || ""}": ${lastError}`;
+        return { success: false, message: `Cannot click ${refLabel}: ${lastError}` };
       }
       if (attempt === 0) {
         await new Promise((r) => setTimeout(r, 50));
@@ -1105,11 +1183,9 @@ Refs:
         clickCount: 1
       });
       await new Promise((r) => setTimeout(r, 300));
-      const ref2 = this.refCache.get(refId);
-      return `Clicked [${refId}] ${ref2?.role || ""} "${ref2?.name || ""}"`;
+      return { success: true, message: `Clicked ${refLabel}` };
     }
-    const ref = this.refCache.get(refId);
-    return `Cannot click [${refId}] ${ref?.role || ""} "${ref?.name || ""}": ${lastError}`;
+    return { success: false, message: `Cannot click ${refLabel}: ${lastError}` };
   }
   /**
    * Type text into an element by ref using CDP Input events.
@@ -1118,37 +1194,49 @@ Refs:
    */
   async typeRef(refId, text) {
     this.ensureConnected();
+    const ref = this.refCache.get(refId);
+    const refLabel = `[${refId}] ${ref?.role || ""} "${ref?.name || ""}"`;
     const clickResult = await this.clickRef(refId);
-    if (clickResult.includes("not found")) return clickResult;
+    if (!clickResult.success) return clickResult;
     await new Promise((r) => setTimeout(r, 100));
-    const modifier = platform() === "darwin" ? 4 : 2;
-    await this.send("Input.dispatchKeyEvent", {
-      type: "keyDown",
-      modifiers: modifier,
-      key: "a",
-      code: "KeyA",
-      windowsVirtualKeyCode: 65
-    });
-    await this.send("Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: "a",
-      code: "KeyA"
-    });
-    await this.send("Input.dispatchKeyEvent", {
-      type: "keyDown",
-      key: "Backspace",
-      code: "Backspace",
-      windowsVirtualKeyCode: 8
-    });
-    await this.send("Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: "Backspace",
-      code: "Backspace"
+    const selectAllKey = platform() === "darwin" ? "Meta+a" : "Control+a";
+    await this.pressKey(selectAllKey);
+    await new Promise((r) => setTimeout(r, 50));
+    await this.pressKey("Backspace");
+    await new Promise((r) => setTimeout(r, 50));
+    const cleared = await this.send("Runtime.evaluate", {
+      expression: `
+        (function() {
+          var el = document.querySelector('[data-assistme-ref="${refId}"]');
+          if (!el) return 'no_element';
+          if (el.value !== undefined && el.value !== '') {
+            // Ctrl+A didn't work (some frameworks intercept it) \u2014 clear via JS
+            var setter = Object.getOwnPropertyDescriptor(
+              window.HTMLInputElement.prototype, 'value'
+            )?.set || Object.getOwnPropertyDescriptor(
+              window.HTMLTextAreaElement.prototype, 'value'
+            )?.set;
+            if (setter) setter.call(el, '');
+            else el.value = '';
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+            return 'js_cleared';
+          }
+          return 'ok';
+        })()
+      `,
+      returnByValue: true
     });
+    const clearStatus = cleared.result?.value || "ok";
+    if (clearStatus === "no_element") {
+      return {
+        success: false,
+        message: `Ref ${refLabel} not found after click. Take a new snapshot.`
+      };
+    }
     await this.send("Input.insertText", { text });
     await new Promise((r) => setTimeout(r, 100));
-    const ref = this.refCache.get(refId);
-    return `Typed "${text}" into [${refId}] ${ref?.role || ""} "${ref?.name || ""}"`;
+    return { success: true, message: `Typed "${text}" into ${refLabel}` };
   }
   /**
    * Select a dropdown option by ref. Delegates to selectOption with the
@@ -1159,13 +1247,16 @@ Refs:
     this.ensureConnected();
     const cached = this.refCache.get(refId);
     if (!cached) {
-      return `Ref [${refId}] not found. Take a new snapshot with browser_snapshot.`;
+      return {
+        success: false,
+        message: `Ref [${refId}] not found. Take a new snapshot with browser_snapshot.`
+      };
     }
+    const refLabel = `[${refId}] ${cached.role} "${cached.name}"`;
     const result = await this.selectOption(`[data-assistme-ref="${refId}"]`, option);
-    return result.replace(
-      /\[data-assistme-ref="\d+"\]/,
-      `[${refId}] ${cached.role} "${cached.name}"`
-    );
+    const message = result.replace(/\[data-assistme-ref="\d+"\]/, refLabel);
+    const success = !result.includes("not found");
+    return { success, message };
   }
   // ── Action Pipeline ───────────────────────────────────────────────
   /**
@@ -1183,18 +1274,24 @@ Refs:
       let success = true;
       try {
         switch (spec.action) {
-          case "click":
-            result = await this.clickRef(spec.ref);
-            success = !result.includes("not found");
+          case "click": {
+            const r = await this.clickRef(spec.ref);
+            result = r.message;
+            success = r.success;
             break;
-          case "type":
-            result = await this.typeRef(spec.ref, spec.text);
-            success = !result.includes("not found");
+          }
+          case "type": {
+            const r = await this.typeRef(spec.ref, spec.text);
+            result = r.message;
+            success = r.success;
             break;
-          case "select":
-            result = await this.selectRef(spec.ref, spec.option);
-            success = !result.includes("not found");
+          }
+          case "select": {
+            const r = await this.selectRef(spec.ref, spec.option);
+            result = r.message;
+            success = r.success;
             break;
+          }
           case "press":
             result = await this.pressKey(spec.key);
             break;
@@ -1269,15 +1366,24 @@ Refs:
           // Strategy 2: Custom dropdown \u2014 find the trigger element
           var trigger = selectEl;
           if (!trigger) {
-            // Try finding by label/placeholder text
-            var allEls = document.querySelectorAll('*');
-            for (var j = 0; j < allEls.length; j++) {
-              var el = allEls[j];
+            // Try finding by aria-label first (fast, indexed)
+            trigger = document.querySelector('[aria-label="' + sel.replace(/"/g, '\\"') + '"]');
+          }
+          if (!trigger) {
+            // Try finding by label/placeholder text in likely dropdown elements
+            var dropdownCandidates = document.querySelectorAll(
+              'button, [role="combobox"], [role="listbox"], [role="button"], ' +
+              'select, input, .MuiSelect-root, .MuiInput-root, ' +
+              '[class*="select"], [class*="dropdown"], [class*="picker"]'
+            );
+            for (var j = 0; j < dropdownCandidates.length; j++) {
+              var el = dropdownCandidates[j];
               var ownText = Array.from(el.childNodes)
                 .filter(function(n) { return n.nodeType === 3; })
                 .map(function(n) { return n.textContent.trim(); })
                 .join('');
-              if (ownText === sel || el.getAttribute('aria-label') === sel) {
+              if (ownText === sel || el.getAttribute('aria-label') === sel ||
+                  el.getAttribute('placeholder') === sel) {
                 trigger = el;
                 break;
               }
@@ -1314,10 +1420,13 @@ Refs:
                 }
               }
 
-              // Broader search: any visible element with exact text match
-              var everything = document.querySelectorAll('*');
-              for (var m = 0; m < everything.length; m++) {
-                var candidate = everything[m];
+              // Broader search: visible leaf elements in interactive containers
+              var broadCandidates = document.querySelectorAll(
+                'li, span, div, a, button, label, [role="option"], [role="menuitem"], ' +
+                '[role="menuitemradio"], [role="menuitemcheckbox"], [data-value]'
+              );
+              for (var m = 0; m < broadCandidates.length; m++) {
+                var candidate = broadCandidates[m];
                 if (candidate.textContent && candidate.textContent.trim() === optText &&
                     candidate.offsetParent !== null && candidate.children.length === 0) {
                   candidate.click();
@@ -1390,6 +1499,7 @@ Refs:
   // ── Helpers ─────────────────────────────────────────────────────
   async waitForLoad(timeoutMs = 8e3) {
     const start = Date.now();
+    let sawInteractive = false;
     while (Date.now() - start < timeoutMs) {
       try {
         const result = await this.send("Runtime.evaluate", {
@@ -1397,67 +1507,22 @@ Refs:
           returnByValue: true
         });
         const state = result.result?.value;
-        if (state === "complete" || state === "interactive") {
-          await new Promise((r) => setTimeout(r, 500));
+        if (state === "complete") {
+          await new Promise((r) => setTimeout(r, 300));
           return;
         }
+        if (state === "interactive") {
+          if (!sawInteractive) {
+            sawInteractive = true;
+          }
+        }
       } catch {
       }
       await new Promise((r) => setTimeout(r, 300));
     }
-  }
-  /**
-   * Find interactive elements on the page for the AI to understand what's clickable
-   */
-  async getInteractiveElements() {
-    this.ensureConnected();
-    const result = await this.send("Runtime.evaluate", {
-      expression: `
-        (function() {
-          const elements = [];
-          const selectors = 'a, button, input, select, textarea, [role="button"], [onclick]';
-          const all = document.querySelectorAll(selectors);
-          for (let i = 0; i < all.length && elements.length < 50; i++) {
-            const el = all[i];
-            const rect = el.getBoundingClientRect();
-            if (rect.width === 0 || rect.height === 0) continue; // Skip hidden
-
-            // Build a reliable CSS selector
-            let selector;
-            if (el.id) {
-              selector = '#' + CSS.escape(el.id);
-            } else if (el.getAttribute('data-testid')) {
-              selector = '[data-testid="' + el.getAttribute('data-testid') + '"]';
-            } else {
-              // Build a path-based selector: find nth-of-type among siblings
-              const tag = el.tagName.toLowerCase();
-              const parent = el.parentElement;
-              if (parent) {
-                const siblings = parent.querySelectorAll(':scope > ' + tag);
-                const idx = Array.from(siblings).indexOf(el) + 1;
-                selector = tag + ':nth-of-type(' + idx + ')';
-              } else {
-                selector = tag;
-              }
-            }
-
-            elements.push({
-              tag: el.tagName.toLowerCase(),
-              text: (el.textContent || '').trim().slice(0, 80),
-              type: el.getAttribute('type') || '',
-              name: el.getAttribute('name') || '',
-              id: el.id || '',
-              href: el.getAttribute('href') || '',
-              placeholder: el.getAttribute('placeholder') || '',
-              selector: selector,
-            });
-          }
-          return JSON.stringify(elements, null, 2);
-        })()
-      `,
-      returnByValue: true
-    });
-    return result.result?.value || "[]";
+    if (sawInteractive) {
+      await new Promise((r) => setTimeout(r, 300));
+    }
   }
   isConnected() {
     return this.connected && this.ws?.readyState === WebSocket.OPEN;
@@ -1796,12 +1861,14 @@ async function ensureBrowserAvailable(port = 9222) {
     detail: "Could not start browser with remote debugging. Possible causes:\n  1) Another assistme debug browser is already using port " + port + "\n  2) The browser crashed on startup\nTry: rm -rf ~/.assistme/browser-profile && assistme"
   };
 }
-var browserInstance = null;
+var browserInstances = /* @__PURE__ */ new Map();
 function getBrowser(port = 9222) {
-  if (!browserInstance) {
-    browserInstance = new BrowserController(port);
+  let instance = browserInstances.get(port);
+  if (!instance) {
+    instance = new BrowserController(port);
+    browserInstances.set(port, instance);
   }
-  return browserInstance;
+  return instance;
 }
 
 // src/commands/browser.ts
@@ -3508,9 +3575,6 @@ async function executeTool(name, input) {
     case "browser_scroll":
       await ensureConnected(browser);
       return input.direction === "up" ? browser.scrollUp() : browser.scrollDown();
-    case "browser_get_elements":
-      await ensureConnected(browser);
-      return browser.getInteractiveElements();
     case "browser_select":
       await ensureConnected(browser);
       return browser.selectOption(input.selector, input.option);
@@ -3691,7 +3755,6 @@ var BROWSER_TOOL_NAMES = [
   "browser_type",
   "browser_press_key",
   "browser_scroll",
-  "browser_get_elements",
   "browser_select",
   "browser_snapshot",
   "browser_act",
@@ -3734,13 +3797,7 @@ function createBrowserMcpServer() {
           const base64 = await executeTool("browser_screenshot", {});
           if (base64.length > 100) {
             return {
-              content: [
-                {
-                  type: "image",
-                  data: base64,
-                  mimeType: "image/png"
-                }
-              ]
+              content: [{ type: "image", data: base64, mimeType: "image/png" }]
             };
           }
           return { content: [{ type: "text", text: base64 }] };
@@ -3773,12 +3830,6 @@ function createBrowserMcpServer() {
         { direction: z.string().describe("'down' or 'up'") },
         async (args) => callTool("browser_scroll", args)
       ),
-      tool(
-        "browser_get_elements",
-        "Find all interactive elements (links, buttons, inputs) on the current page.",
-        {},
-        async () => callTool("browser_get_elements", {})
-      ),
       tool(
         "browser_select",
         "Select an option from a dropdown menu. Handles both native <select> elements and custom dropdowns (Material Design, React, Angular). Use this instead of manually clicking dropdown items.",
@@ -3807,11 +3858,7 @@ function createBrowserMcpServer() {
           const imageData = parts[1] || "";
           const content = [];
           if (imageData.length > 100) {
-            content.push({
-              type: "image",
-              data: imageData,
-              mimeType: "image/png"
-            });
+            content.push({ type: "image", data: imageData, mimeType: "image/png" });
           }
           content.push({ type: "text", text: refTable });
           return { content };
@@ -3847,11 +3894,7 @@ function createBrowserMcpServer() {
           const content = [];
           content.push({ type: "text", text: actionText });
           if (screenshotData.length > 100) {
-            content.push({
-              type: "image",
-              data: screenshotData,
-              mimeType: "image/png"
-            });
+            content.push({ type: "image", data: screenshotData, mimeType: "image/png" });
           }
           return { content };
         }
@@ -4154,7 +4197,7 @@ function getCredentialStore() {
 
 // src/mcp/agent-tools-server.ts
 function createAgentToolsServer(deps) {
-  const { memoryManager, skillManager, taskId, sessionId } = deps;
+  const { memoryManager, skillManager, taskId, sessionId, onUserWaitStart, onUserWaitEnd } = deps;
   return createSdkMcpServer2({
     name: "assistme-agent",
     version: "1.0.0",
@@ -4659,52 +4702,56 @@ Use \`ask_user\` to request these from the user, or create them yourself (e.g. r
           try {
             await setActionRequest(taskId, actionData);
             log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {
-            });
-            emitEvent(taskId, "status_change", {
+            await emitEvent(taskId, "user_action_request", actionData);
+            await emitEvent(taskId, "status_change", {
               status: "waiting_for_user",
               message: args.question
-            }).catch(() => {
             });
+            onUserWaitStart?.();
             const startTime = Date.now();
             const pollInterval = 2e3;
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                const actionKey = response.action_key || "";
-                const text = response.text || "";
-                const label = response.label || actionKey || text;
-                log.info(`User responded: "${label}"`);
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: JSON.stringify({
-                        status: "responded",
-                        action_key: actionKey || "custom_input",
-                        label,
-                        text: text || label
-                      })
-                    }
-                  ]
-                };
+            try {
+              while (Date.now() - startTime < timeout) {
+                const response = await pollActionResponse(taskId);
+                if (response && (!response.action_id || response.action_id === actionId)) {
+                  const actionKey = response.action_key || "";
+                  const text = response.text || "";
+                  const label = response.label || actionKey || text;
+                  log.info(`User responded: "${label}"`);
+                  return {
+                    content: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          status: "responded",
+                          action_key: actionKey || "custom_input",
+                          label,
+                          text: text || label
+                        })
+                      }
+                    ]
+                  };
+                }
+                await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
               }
-              await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+              log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      status: "timeout",
+                      message: "User did not respond within the timeout period. Continue the task with a reasonable default or skip the step that required user input."
+                    })
+                  }
+                ]
+              };
+            } finally {
+              onUserWaitEnd?.();
             }
-            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    status: "timeout",
-                    message: "User did not respond within the timeout period."
-                  })
-                }
-              ]
-            };
           } catch (err) {
             log.error(`ask_user failed: ${err}`);
+            onUserWaitEnd?.();
             return {
               content: [
                 {
@@ -5125,7 +5172,7 @@ Available capabilities:
    - Refs persist across actions unless the page navigates. Re-snapshot after navigation or major DOM changes.
 
    **Legacy tools (still available, use when refs don't work):**
-   - browser_click, browser_type, browser_select, browser_get_elements, browser_screenshot, browser_evaluate
+   - browser_click, browser_type, browser_select, browser_screenshot, browser_evaluate
    - browser_click supports :contains('text') pseudo-selectors
    - browser_select handles native and custom dropdowns
 
@@ -5138,12 +5185,16 @@ Available capabilities:
    - Bash tool for shell commands
    - Glob and Grep for file search
 
-3. MEMORY:
+3. MEMORY & CREDENTIALS:
    - You can remember things about the user using memory_store
    - Use this when you learn preferences, important facts, or standing instructions
    - Your stored memories persist across conversations
    - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
    - Before completing a task, consider if anything learned should be remembered for future conversations
+   - CRITICAL \u2014 Credential Storage: When you create, register, or receive any account credentials (username, password, API keys, tokens), you MUST use credential_set to save them locally. NEVER use memory_store for credentials \u2014 memory_store is for preferences and facts, credential_set is for secrets. Examples:
+     * After registering a new email/account \u2192 credential_set with type "login" and data { "username": "...", "password": "...", "email": "..." }
+     * After generating an API key \u2192 credential_set with type "api_key" and data { "api_key": "..." }
+     * Credentials saved via credential_set are encrypted on disk and viewable in the desktop app's Credentials panel
 
 4. SKILL-AWARE EXECUTION (CRITICAL \u2014 follow this for EVERY task):
    Step A \u2014 Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
@@ -5223,6 +5274,42 @@ CRITICAL \u2014 Ask before you guess:
 Workspace path: {workspace_path}`;
 
 // src/agent/processor.ts
+var TaskTimeout = class {
+  constructor(abortController, timeoutMs) {
+    this.abortController = abortController;
+    this.remainingMs = timeoutMs;
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  timeoutId = null;
+  remainingMs;
+  resumedAt;
+  schedule() {
+    this.timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, this.remainingMs);
+  }
+  /** Pause the timeout (e.g. while waiting for user). */
+  pause() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+      const elapsed = Date.now() - this.resumedAt;
+      this.remainingMs = Math.max(0, this.remainingMs - elapsed);
+    }
+  }
+  /** Resume the timeout after user interaction completes. */
+  resume() {
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  clear() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
 var MAX_HISTORY_ENTRIES = 10;
 var MAX_RESPONSE_LENGTH = 1500;
 var TaskProcessor = class {
@@ -5305,12 +5392,16 @@ var TaskProcessor = class {
         }
         systemPrompt += historyPrompt;
       }
+      const abortController = new AbortController();
+      const taskTimeout = new TaskTimeout(abortController, taskTimeoutMs);
       const browserServer = createBrowserMcpServer();
       const agentToolsServer = createAgentToolsServer({
         memoryManager: this.memoryManager,
         skillManager: this.skillManager,
         taskId: task.id,
-        sessionId: this.sessionId || void 0
+        sessionId: this.sessionId || void 0,
+        onUserWaitStart: () => taskTimeout.pause(),
+        onUserWaitEnd: () => taskTimeout.resume()
       });
       const eventHooks = createEventHooks(task.id, toolCallRecords);
       const allowedTools = [
@@ -5357,7 +5448,6 @@ var TaskProcessor = class {
           session_id: ""
         };
       }
-      const abortController = new AbortController();
       const options = {
         model: config.model,
         systemPrompt,
@@ -5375,9 +5465,6 @@ var TaskProcessor = class {
         abortController
       };
       const taskStartTime = Date.now();
-      const timeoutId = setTimeout(() => {
-        abortController.abort();
-      }, taskTimeoutMs);
       try {
         for await (const message of query2({
           prompt: promptMessages(),
@@ -5439,9 +5526,11 @@ var TaskProcessor = class {
           }
         }
       } finally {
-        clearTimeout(timeoutId);
+        taskTimeout.clear();
       }
-      await withRetry(() => completeTask(task.id, finalResponse, tokenUsage), {
+      const MAX_CONTENT_LENGTH = 5e4;
+      const truncatedResponse = finalResponse.length > MAX_CONTENT_LENGTH ? finalResponse.slice(0, MAX_CONTENT_LENGTH) + "\n\n[Response truncated]" : finalResponse;
+      await withRetry(() => completeTask(task.id, truncatedResponse, tokenUsage), {
         maxRetries: 2,
         baseDelayMs: 300,
         label: "completeTask"