dipclaw 0.1.0

package/dist/agent/agent.js

@@ -0,0 +1,725 @@
+import { createLlmClient } from "../llm/client.js";
+import { getAllTools } from "../llm/tools.js";
+import { BrowserManager } from "../browser/manager.js";
+import { TaskRunner } from "./task-runner.js";
+import { Scheduler } from "./scheduler.js";
+import { MemoryManager } from "./memory.js";
+import { SkillGenerator } from "./skill-generator.js";
+import { TUI } from "../tui/tui.js";
+import { TelegramBot } from "../telegram/bot.js";
+import { ExecutionLogger } from "../logging/logger.js";
+import path from "node:path";
+export class Agent {
+    config;
+    llmClient;
+    browser;
+    taskRunner;
+    scheduler;
+    memory;
+    skillGenerator;
+    tui = null;
+    telegramBot = null;
+    chatHistory = [];
+    conversationSummary = "";
+    summarizationCooldown = 0;
+    browserLock = Promise.resolve();
+    constructor(config) {
+        this.config = config;
+        this.llmClient = createLlmClient(config);
+        this.browser = new BrowserManager(config);
+        this.memory = new MemoryManager(config.workspace);
+        this.taskRunner = new TaskRunner(config, this.llmClient, this.browser, this.memory);
+        this.scheduler = new Scheduler(config.workspace);
+        this.skillGenerator = new SkillGenerator(config.workspace, this.llmClient);
+        // Give TaskRunner access to scheduler for auto-linking skills
+        this.taskRunner.setScheduler(this.scheduler);
+        // Wire up scheduler to task runner (serialized via browser lock)
+        this.scheduler.setHandler(async (task) => {
+            const lock = this.acquireBrowserLock();
+            await lock.promise;
+            try {
+                console.log(`🔒 Lock acquired for task: ${task.name}`);
+                const result = await this.taskRunner.runTask(task);
+                console.log(`  Task result: ${result.slice(0, 200)}`);
+                // Notify via Telegram if available
+                if (this.telegramBot) {
+                    await this.telegramBot.notify(`✅ Task "${task.name}" completed:\n${result.slice(0, 3800)}`);
+                }
+            }
+            finally {
+                lock.release();
+            }
+        });
+    }
+    async start() {
+        // Launch browser immediately so Chrome lives with this process
+        await this.browser.launch();
+        // Start scheduler
+        this.scheduler.start();
+        // Start Telegram bot if configured
+        if (this.config.telegram) {
+            this.telegramBot = new TelegramBot(this.config.telegram.botToken, this, this.config.telegram.allowedUsers);
+            await this.telegramBot.start();
+        }
+        // Start TUI only if enabled
+        if (this.config.tui) {
+            this.tui = new TUI(this);
+            this.tui.start();
+        }
+    }
+    async stop() {
+        this.scheduler.stop();
+        this.telegramBot?.stop();
+        this.tui?.stop();
+        await this.browser.close();
+    }
+    // --- Public API for TUI/Telegram ---
+    getName() {
+        return this.config.name;
+    }
+    getWorkspace() {
+        return this.config.workspace;
+    }
+    /** Clear chat history and start a new session */
+    clearChat() {
+        this.chatHistory = [];
+        this.conversationSummary = "";
+    }
+    /** Chat with the agent (LLM-driven, with tool use) */
+    async chat(message) {
+        const lock = this.acquireBrowserLock();
+        await lock.promise;
+        try {
+            return await this.chatInner(message);
+        }
+        finally {
+            lock.release();
+        }
+    }
+    async chatInner(message) {
+        this.chatHistory.push({ role: "user", content: message });
+        await this.compressHistory();
+        const memoryIndex = this.memory.loadIndex();
+        const systemPrompt = this.buildChatSystemPrompt(memoryIndex);
+        const tools = getAllTools();
+        let response = await this.llmClient.chat(this.buildMessagesForLlm(), tools, systemPrompt);
+        // Handle tool calls in a loop
+        let iterations = 0;
+        let browserActionCount = 0;
+        const maxIter = this.config.maxIterations;
+        while (response.toolCalls.length > 0 && iterations < maxIter) {
+            iterations++;
+            // Add assistant message with tool calls
+            this.chatHistory.push({
+                role: "assistant",
+                content: response.content,
+                toolCalls: response.toolCalls,
+            });
+            // Execute tools
+            for (const tc of response.toolCalls) {
+                if (tc.name === "browser")
+                    browserActionCount++;
+                let result;
+                try {
+                    result = await this.executeToolCall(tc);
+                }
+                catch (err) {
+                    result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+                this.chatHistory.push({
+                    role: "tool",
+                    content: result,
+                    toolCallId: tc.id,
+                });
+            }
+            // Get next response
+            response = await this.llmClient.chat(this.buildMessagesForLlm(), tools, systemPrompt);
+        }
+        // Reached iteration limit — ask LLM for a final summary without tools
+        if (iterations >= maxIter && response.toolCalls.length > 0) {
+            // Push the last assistant response (with unexecuted tool calls) as text only
+            if (response.content) {
+                this.chatHistory.push({ role: "assistant", content: response.content });
+            }
+            this.chatHistory.push({
+                role: "user",
+                content: "You've reached the maximum number of tool-calling iterations allowed. Please provide a final response summarizing what you've found and accomplished so far, without calling any more tools.",
+            });
+            const summary = await this.llmClient.chat(this.buildMessagesForLlm(), undefined, // no tools — force text-only response
+            systemPrompt);
+            const finalContent = summary.content + "\n\n⚠️ Reached the maximum number of steps. Send a message to continue where I left off.";
+            this.chatHistory.push({ role: "assistant", content: finalContent });
+            return finalContent;
+        }
+        // Nudge: after complex browser interactions, append a reminder
+        if (browserActionCount >= 5 && !response.content.includes("memory")) {
+            response.content += "\n\n💡 _This was a multi-step workflow. I've saved relevant discoveries to memory for future reference._";
+            // Auto-save a memory about the workflow
+            this.autoSaveWorkflowMemory(message, browserActionCount);
+        }
+        // Add final assistant message
+        this.chatHistory.push({
+            role: "assistant",
+            content: response.content,
+        });
+        return response.content;
+    }
+    /**
+     * Auto-save a brief memory about a complex chat workflow.
+     * Non-blocking — fires and forgets.
+     */
+    autoSaveWorkflowMemory(userMessage, actionCount) {
+        const key = `workflow-${Date.now()}`;
+        const title = userMessage.slice(0, 60).replace(/[^a-zA-Z0-9\u4e00-\u9fff\s_-]/g, "");
+        const content = `User request: ${userMessage.slice(0, 200)}\nComplexity: ${actionCount} browser actions\nTimestamp: ${new Date().toISOString()}`;
+        try {
+            this.memory.save(key, title, content);
+        }
+        catch {
+            // Best-effort, don't block chat
+        }
+    }
+    /** Chat with streaming — yields text deltas, handles tool calls internally */
+    async *chatStream(message) {
+        const lock = this.acquireBrowserLock();
+        await lock.promise;
+        try {
+            yield* this.chatStreamInner(message);
+        }
+        finally {
+            lock.release();
+        }
+    }
+    async *chatStreamInner(message) {
+        this.chatHistory.push({ role: "user", content: message });
+        await this.compressHistory();
+        const memoryIndex = this.memory.loadIndex();
+        const systemPrompt = this.buildChatSystemPrompt(memoryIndex);
+        const tools = getAllTools();
+        let iterations = 0;
+        let browserActionCount = 0;
+        const maxIter = this.config.maxIterations;
+        while (iterations < maxIter) {
+            iterations++;
+            let fullContent = "";
+            const toolCalls = [];
+            let hadToolCalls = false;
+            for await (const event of this.llmClient.chatStream(this.buildMessagesForLlm(), tools, systemPrompt)) {
+                if (event.type === "text_delta" && event.text) {
+                    fullContent += event.text;
+                    yield event.text;
+                }
+                else if (event.type === "tool_call_end" && event.toolCall) {
+                    hadToolCalls = true;
+                    toolCalls.push({
+                        id: event.toolCall.id,
+                        name: event.toolCall.name,
+                        arguments: event.toolCall.arguments || {},
+                    });
+                }
+            }
+            if (!hadToolCalls) {
+                // Nudge: after complex browser interactions, auto-save workflow memory
+                if (browserActionCount >= 5) {
+                    this.autoSaveWorkflowMemory(message, browserActionCount);
+                    yield "\n\n💡 _Multi-step workflow completed. Key discoveries saved to memory._";
+                }
+                this.chatHistory.push({ role: "assistant", content: fullContent });
+                return;
+            }
+            // Process tool calls, then loop for next LLM response
+            this.chatHistory.push({
+                role: "assistant",
+                content: fullContent,
+                toolCalls,
+            });
+            for (const tc of toolCalls) {
+                if (tc.name === "browser")
+                    browserActionCount++;
+                let result;
+                try {
+                    result = await this.executeToolCall(tc);
+                }
+                catch (err) {
+                    result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+                this.chatHistory.push({
+                    role: "tool",
+                    content: result,
+                    toolCallId: tc.id,
+                });
+            }
+            // yield a visual separator so user knows tools ran
+            yield "\n";
+        }
+        // Reached iteration limit — ask LLM for a final summary without tools
+        this.chatHistory.push({
+            role: "user",
+            content: "You've reached the maximum number of tool-calling iterations allowed. Please provide a final response summarizing what you've found and accomplished so far, without calling any more tools.",
+        });
+        let summaryContent = "";
+        for await (const event of this.llmClient.chatStream(this.buildMessagesForLlm(), undefined, // no tools — force text-only response
+        systemPrompt)) {
+            if (event.type === "text_delta" && event.text) {
+                summaryContent += event.text;
+                yield event.text;
+            }
+        }
+        const suffix = "\n\n⚠️ Reached the maximum number of steps. Send a message to continue where I left off.";
+        this.chatHistory.push({ role: "assistant", content: summaryContent + suffix });
+        yield suffix;
+    }
+    listTasks() {
+        return this.scheduler.formatTaskList();
+    }
+    addTask(name, cron, prompt) {
+        try {
+            const task = this.scheduler.addTask(name, cron, prompt);
+            return `✓ Task added: [${task.id}] ${task.name} (${task.cron})`;
+        }
+        catch (err) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    removeTask(id) {
+        return this.scheduler.removeTask(id)
+            ? `✓ Task ${id} removed.`
+            : `Task ${id} not found.`;
+    }
+    toggleTask(id, enabled) {
+        const task = this.scheduler.toggleTask(id, enabled);
+        return task
+            ? `✓ Task ${id} ${enabled ? "enabled" : "disabled"}.`
+            : `Task ${id} not found.`;
+    }
+    async runTaskById(id) {
+        const task = this.scheduler.getTask(id);
+        if (!task)
+            return `Task ${id} not found.`;
+        const lock = this.acquireBrowserLock();
+        await lock.promise;
+        try {
+            const result = await this.taskRunner.runTask(task);
+            this.scheduler.updateTaskStatus(id, "ok");
+            return result;
+        }
+        catch (err) {
+            this.scheduler.updateTaskStatus(id, "error");
+            return `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        finally {
+            lock.release();
+        }
+    }
+    listSkills() {
+        return this.skillGenerator.listSkills();
+    }
+    async generateSkill(logFileName) {
+        const logsDir = path.join(this.config.workspace, "logs");
+        const logs = ExecutionLogger.listLogs(logsDir);
+        const match = logs.find((l) => l.includes(logFileName));
+        if (!match)
+            return `Log file not found: ${logFileName}`;
+        const logPath = path.join(logsDir, match);
+        return await this.skillGenerator.generate(logPath);
+    }
+    listMemories() {
+        return this.memory.list();
+    }
+    /**
+     * Estimate character count of the chat history (rough proxy for tokens).
+     */
+    estimateHistoryChars() {
+        let total = 0;
+        for (const msg of this.chatHistory) {
+            const content = typeof msg.content === "string"
+                ? msg.content
+                : JSON.stringify(msg.content);
+            total += content.length;
+            if (msg.toolCalls) {
+                total += JSON.stringify(msg.toolCalls).length;
+            }
+        }
+        return total;
+    }
+    /**
+     * Compress chat history: try LLM summarization first, fallback to simple trim.
+     */
+    async compressHistory() {
+        const SOFT_LIMIT = 20_000;
+        const HARD_LIMIT = 30_000;
+        const TARGET = 15_000;
+        const currentChars = this.estimateHistoryChars();
+        if (currentChars <= SOFT_LIMIT)
+            return;
+        // Try LLM summarization if not on cooldown
+        if (this.summarizationCooldown <= 0) {
+            try {
+                await this.performSummarization(currentChars, TARGET);
+                return;
+            }
+            catch (err) {
+                console.error("⚠️ Summarization failed, falling back to trim:", err);
+                this.summarizationCooldown = 3;
+            }
+        }
+        if (this.summarizationCooldown > 0) {
+            this.summarizationCooldown--;
+        }
+        // Fallback: simple trim at hard limit
+        if (this.estimateHistoryChars() > HARD_LIMIT) {
+            this.simpleTrim(HARD_LIMIT);
+        }
+    }
+    /**
+     * Summarize old messages via LLM and replace them with a compressed summary.
+     */
+    async performSummarization(currentChars, target) {
+        const excess = currentChars - target;
+        const history = this.chatHistory;
+        // Collect safe cut indices (user message boundaries)
+        const safeCuts = [];
+        for (let i = 1; i < history.length; i++) {
+            if (history[i].role === "user") {
+                safeCuts.push(i);
+            }
+        }
+        if (safeCuts.length === 0)
+            return;
+        // Find the cut that removes approximately `excess` chars
+        let cutIndex = 0;
+        for (const sci of safeCuts) {
+            let chars = 0;
+            for (let i = 0; i < sci; i++) {
+                const c = typeof history[i].content === "string"
+                    ? history[i].content
+                    : JSON.stringify(history[i].content);
+                chars += c.length;
+                if (history[i].toolCalls)
+                    chars += JSON.stringify(history[i].toolCalls).length;
+            }
+            cutIndex = sci;
+            if (chars >= excess)
+                break;
+        }
+        if (cutIndex <= 0)
+            return;
+        const messagesToSummarize = history.slice(0, cutIndex);
+        console.log(`📝 Summarizing ${messagesToSummarize.length} messages (${currentChars} chars → ~${target} target)...`);
+        const summary = await this.summarizeMessages(messagesToSummarize);
+        this.conversationSummary = summary;
+        this.chatHistory = history.slice(cutIndex);
+        console.log(`📝 Summary complete (${summary.length} chars). History now: ${this.estimateHistoryChars()} chars.`);
+    }
+    /**
+     * Format messages and call LLM to produce a conversation summary.
+     */
+    async summarizeMessages(messages) {
+        const formatted = this.formatMessagesForSummary(messages);
+        let prompt = `Summarize the conversation between a user and a browser automation agent.
+Your summary will replace the original messages to save context space.
+
+`;
+        if (this.conversationSummary) {
+            prompt += `## Previous Summary
+${this.conversationSummary}
+
+`;
+        }
+        prompt += `## Messages to Summarize
+${formatted}
+
+## Instructions
+Produce a structured summary (under 3000 characters) capturing:
+1. **User Goals**: What the user wants to accomplish
+2. **Actions Taken**: URLs visited, forms filled, data extracted
+3. **Results**: Outcomes, findings, extracted data
+4. **Errors & Recovery**: Problems encountered and resolutions
+5. **Decisions**: Choices made by user or agent
+6. **Current State**: Where things stand now
+7. **Pending**: Anything not yet completed
+
+Merge with previous summary if present. Omit empty sections.
+Focus on facts, not conversational niceties.`;
+        const response = await this.llmClient.chat([{ role: "user", content: prompt }], undefined, "You are a conversation summarizer. Be concise and precise.");
+        return response.content;
+    }
+    /**
+     * Format chat messages into readable text for the summarizer.
+     * Skips snapshot content (ephemeral page state, too large for summaries).
+     */
+    formatMessagesForSummary(messages) {
+        // Collect snapshot toolCallIds to skip their results
+        const snapshotToolCallIds = new Set();
+        for (const msg of messages) {
+            if (msg.role === "assistant" && msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    if (tc.name === "browser" && tc.arguments.action === "snapshot") {
+                        snapshotToolCallIds.add(tc.id);
+                    }
+                }
+            }
+        }
+        return messages
+            .map((msg) => {
+            const content = typeof msg.content === "string"
+                ? msg.content
+                : msg.content
+                    .map((b) => (b.type === "image" ? "[image]" : b.text || ""))
+                    .join("");
+            if (msg.role === "user") {
+                return `User: ${content}`;
+            }
+            else if (msg.role === "assistant" && msg.toolCalls?.length) {
+                const toolsSummary = msg.toolCalls
+                    .map((tc) => `${tc.name}(${tc.arguments.action || JSON.stringify(tc.arguments).slice(0, 100)})`)
+                    .join(", ");
+                const textPart = content ? `${content}\n` : "";
+                return `Agent: ${textPart}[Called: ${toolsSummary}]`;
+            }
+            else if (msg.role === "tool") {
+                // Skip snapshot results entirely
+                if (msg.toolCallId && snapshotToolCallIds.has(msg.toolCallId)) {
+                    return `Tool result: [browser snapshot omitted]`;
+                }
+                const truncated = content.length > 500
+                    ? content.slice(0, 500) + "...(truncated)"
+                    : content;
+                return `Tool result: ${truncated}`;
+            }
+            else {
+                return `Agent: ${content}`;
+            }
+        })
+            .join("\n\n");
+    }
+    /**
+     * Simple trim: drop old messages at user-message boundaries to fit budget.
+     * Fallback when summarization is unavailable.
+     */
+    simpleTrim(maxChars) {
+        if (this.estimateHistoryChars() <= maxChars)
+            return;
+        const history = this.chatHistory;
+        const safeCuts = [];
+        for (let i = 0; i < history.length; i++) {
+            if (history[i].role === "user") {
+                safeCuts.push(i);
+            }
+        }
+        for (let ci = safeCuts.length - 1; ci >= 0; ci--) {
+            const cutIdx = safeCuts[ci];
+            if (cutIdx === 0)
+                continue;
+            const candidate = history.slice(cutIdx);
+            let chars = 0;
+            for (const msg of candidate) {
+                const c = typeof msg.content === "string"
+                    ? msg.content
+                    : JSON.stringify(msg.content);
+                chars += c.length;
+                if (msg.toolCalls)
+                    chars += JSON.stringify(msg.toolCalls).length;
+            }
+            if (chars <= maxChars) {
+                this.chatHistory = candidate;
+                return;
+            }
+        }
+        // Fallback: keep only the last user message and following messages
+        for (let i = history.length - 1; i >= 0; i--) {
+            if (history[i].role === "user") {
+                this.chatHistory = history.slice(i);
+                return;
+            }
+        }
+        this.chatHistory = [history[history.length - 1]];
+    }
+    /**
+     * Build a copy of chatHistory with snapshot results managed:
+     * - If the latest user message involves browser activity, keep only the most recent snapshot.
+     * - Otherwise, omit all snapshots.
+     */
+    buildMessagesForLlm() {
+        // 1. Collect all snapshot toolCallIds
+        const snapshotToolCallIds = new Set();
+        for (const msg of this.chatHistory) {
+            if (msg.role === "assistant" && msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    if (tc.name === "browser" && tc.arguments.action === "snapshot") {
+                        snapshotToolCallIds.add(tc.id);
+                    }
+                }
+            }
+        }
+        if (snapshotToolCallIds.size === 0)
+            return this.chatHistory;
+        // 2. Check if the most recent turn involves browser tool calls
+        //    (i.e., the last assistant message has browser tool calls, or there's a pending browser interaction)
+        let lastTurnUsesBrowser = false;
+        for (let i = this.chatHistory.length - 1; i >= 0; i--) {
+            const msg = this.chatHistory[i];
+            if (msg.role === "user") {
+                // The latest user message — stop here, browser context depends on what follows
+                break;
+            }
+            if (msg.role === "assistant" && msg.toolCalls) {
+                if (msg.toolCalls.some((tc) => tc.name === "browser")) {
+                    lastTurnUsesBrowser = true;
+                }
+                break;
+            }
+        }
+        // 3. Find the last snapshot id (only needed if browser is active)
+        let lastSnapshotId;
+        if (lastTurnUsesBrowser) {
+            for (let i = this.chatHistory.length - 1; i >= 0; i--) {
+                const msg = this.chatHistory[i];
+                if (msg.role === "tool" && msg.toolCallId && snapshotToolCallIds.has(msg.toolCallId)) {
+                    lastSnapshotId = msg.toolCallId;
+                    break;
+                }
+            }
+        }
+        // 4. Build messages: keep only the latest snapshot if browser active, omit all otherwise
+        return this.chatHistory.map((msg) => {
+            if (msg.role === "tool" &&
+                msg.toolCallId &&
+                snapshotToolCallIds.has(msg.toolCallId) &&
+                msg.toolCallId !== lastSnapshotId) {
+                return { ...msg, content: "(snapshot omitted)" };
+            }
+            return msg;
+        });
+    }
+    // --- Private helpers ---
+    async executeToolCall(tc) {
+        const args = tc.arguments;
+        const action = args.action;
+        switch (tc.name) {
+            case "browser":
+                return await this.executeBrowserAction(action, args);
+            case "memory":
+                return this.executeMemoryAction(action, args);
+            case "scheduler":
+                return this.executeSchedulerAction(action, args);
+            default:
+                return `Unknown tool: ${tc.name}`;
+        }
+    }
+    async executeBrowserAction(action, args) {
+        const { BrowserActions } = await import("../browser/actions.js");
+        const actions = new BrowserActions(this.browser);
+        switch (action) {
+            case "navigate":
+                return await actions.navigate(args.url);
+            case "snapshot":
+                return await actions.snapshot();
+            case "click":
+                return await actions.click(args.ref);
+            case "type":
+                return await actions.type(args.ref, args.text, args.clear);
+            case "scroll":
+                return await actions.scroll(args.direction, args.amount, args.ref);
+            case "screenshot": {
+                const ss = await actions.screenshot(args.fullPage);
+                return ss.text;
+            }
+            case "evaluate":
+                return await actions.evaluate(args.script);
+            case "wait":
+                return await actions.wait(args);
+            case "press":
+                return await actions.pressKey(args.key);
+            case "select":
+                return await actions.selectOption(args.ref, args.value);
+            case "tabs":
+                return await actions.listTabs();
+            case "close_tab":
+                return await actions.closeTab(args.index);
+            case "focus_tab":
+                return await actions.focusTab(args.index);
+            default:
+                return `Unknown browser action: ${action}`;
+        }
+    }
+    executeMemoryAction(action, args) {
+        switch (action) {
+            case "save":
+                return this.memory.save(args.key, args.title, args.content);
+            case "read":
+                return this.memory.read(args.key);
+            case "list":
+                return this.memory.list();
+            default:
+                return `Unknown memory action: ${action}`;
+        }
+    }
+    executeSchedulerAction(action, args) {
+        switch (action) {
+            case "list":
+                return this.listTasks();
+            case "add":
+                return this.addTask(args.name, args.cron, args.prompt);
+            case "remove":
+                return this.removeTask(args.id);
+            case "toggle":
+                return this.toggleTask(args.id, args.enabled);
+            default:
+                return `Unknown scheduler action: ${action}`;
+        }
+    }
+    buildChatSystemPrompt(memoryIndex) {
+        let prompt = `You are "${this.config.name}", a browser automation assistant. You help users by controlling a web browser and managing scheduled tasks.
+
+## Capabilities
+- Browse the web: navigate, click, type, scroll, take screenshots, extract data
+- Manage scheduled tasks: add, remove, enable/disable cron-based tasks
+- Remember things: save and recall important information across sessions
+- Generate skills: create reusable automation scripts from execution logs
+
+## How to use browser tool
+1. Call browser with action "navigate" to go to a URL
+2. Call browser with action "snapshot" to see the page (you'll get element refs like [e1], [e2])
+3. Call browser with action "click", "type", etc. using element references
+4. After actions, snapshot again to verify results
+
+## Guidelines
+- Always snapshot before interacting with page elements
+- Be concise in responses
+- Manage scheduled tasks with the scheduler tool
+
+## Learning & Memory (IMPORTANT)
+You have a persistent memory system. Proactively save knowledge that would be valuable in future sessions:
+- **Website patterns**: Login flows, page structures, selectors that work, CAPTCHAs, rate limits
+- **User preferences**: How the user likes data formatted, which sites they frequent, credentials notes (never passwords)
+- **Task insights**: Workarounds discovered, timing that works best, error recovery strategies
+- **Domain knowledge**: Business rules, data relationships, naming conventions found during browsing
+
+When you complete a multi-step browser task, ask yourself: "Would this workflow be useful again?" If yes, suggest the user create a scheduled task — the system will automatically learn and optimize it over time.
+
+Do NOT ask permission every time — just save important discoveries. Use descriptive keys like "site-twitter-login-flow" or "workaround-cloudflare-challenge".`;
+        if (this.conversationSummary) {
+            prompt += `\n\n## Earlier Conversation Summary\n${this.conversationSummary}`;
+        }
+        if (memoryIndex.trim().length > 20) {
+            prompt += `\n\n## Saved Memories\n${memoryIndex}`;
+        }
+        return prompt;
+    }
+    /**
+     * Acquire a serialized lock for browser access.
+     * All operations that may use the browser (chat, scheduled tasks) must go through this
+     * to prevent concurrent browser manipulation.
+     */
+    acquireBrowserLock() {
+        let release;
+        const next = new Promise((resolve) => {
+            release = resolve;
+        });
+        const promise = this.browserLock;
+        this.browserLock = this.browserLock.then(() => next);
+        return { promise, release };
+    }
+}
+//# sourceMappingURL=agent.js.map