@lasso-ai/cli 1.3.2 → 1.3.3

package/dist/cli/agent.js

@@ -19,6 +19,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const auth_1 = require("./auth");
+const layout_intelligence_1 = require("@lasso-ai/layout-intelligence");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
 function detectProjectStructure(cwd) {
@@ -1002,6 +1003,22 @@ async function proposeChanges(cwd, input, config, signal, onProgress, onPrompt)
         : "";
     // Detect project structure for instruction
     const structure = detectProjectStructure(cwd);
+    // Query layout intelligence for relevant patterns
+    let layoutContext = "";
+    try {
+        const layoutQuery = input.instruction;
+        const relevantLayouts = await (0, layout_intelligence_1.searchLayouts)(layoutQuery);
+        if (relevantLayouts.length > 0) {
+            layoutContext = `\n\nLAYOUT INTELLIGENCE:
+Based on your request, here are relevant layout patterns you should consider:
+${relevantLayouts.slice(0, 3).map((result) => `- ${result.pattern.name}: ${result.pattern.description}`).join("\n")}
+Use these patterns as inspiration for your implementation. Focus on matching the layout structure, spacing, and composition principles.`;
+        }
+    }
+    catch (error) {
+        // Layout intelligence is optional; continue without it if it fails
+        console.warn("Layout intelligence query failed:", error);
+    }
     const instruction = `Selection context:
 ${JSON.stringify(input.element, null, 2)}
 ${JSON.stringify(visualContext, null, 2)}
@@ -1016,7 +1033,7 @@ Previous change history for this selection:
 ${priorChanges}
 
 Relevant source context:
-${context || "No matching source context was found. Ask for a more specific selection rather than inventing a file."}${dragHint}${runtimeErrorHint}
+${context || "No matching source context was found. Ask for a more specific selection rather than inventing a file."}${dragHint}${runtimeErrorHint}${layoutContext}
 
 CRITICAL INSTRUCTIONS:
 0. PROJECT STRUCTURE AWARENESS: This project has specific directory structure. Before creating or moving files, verify the actual structure. Do not assume standard locations.

package/dist/cli/bridge.d.ts

@@ -1,5 +1,6 @@
 import { type SourceChange, type AgentPrompt } from "./agent";
 import type { CollabConfig } from "./project";
+import { type TimelineSnapshot, type ConflictInfo } from "./snapshot";
 export declare const DEFAULT_BRIDGE_PORT = 3056;
 type GitState = {
     isRepo: boolean;
@@ -143,6 +144,19 @@ export type BridgeMessage = {
     }>;
     taskId?: string;
     pageContext?: any;
+} | {
+    type: "resolve_conflict";
+    taskId: string;
+    action: "retry" | "force" | "rebase";
+    conflicts: ConflictInfo[];
+} | {
+    type: "restore_snapshot";
+    snapshotId: string;
+} | {
+    type: "get_timeline";
+} | {
+    type: "delete_snapshot";
+    snapshotId: string;
 };
 type ModelOption = {
     id: string;
@@ -235,6 +249,14 @@ export type ServerBridgeMessage = {
     text?: string;
     provider?: string;
     error?: string;
+} | {
+    type: "conflict_detected";
+    taskId: string;
+    conflicts: ConflictInfo[];
+    message: string;
+} | {
+    type: "timeline";
+    snapshots: TimelineSnapshot[];
 };
 export declare function restartBridge(port?: number): Promise<{
     ok: boolean;

package/dist/cli/bridge.js

@@ -17,6 +17,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const agent_1 = require("./agent");
 const project_1 = require("./project");
 const auth_1 = require("./auth");
+const snapshot_1 = require("./snapshot");
 exports.DEFAULT_BRIDGE_PORT = 3056;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 async function restartBridge(port = exports.DEFAULT_BRIDGE_PORT) {
@@ -435,6 +436,120 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         fileEnv.NEXT_LASSO_API_KEY ||
         "";
     const lassoKeyConfigured = Boolean(resolvedLassoKey);
+    // Task queue for concurrent execution
+    const MAX_CONCURRENT_TASKS = 3;
+    const taskQueue = [];
+    const runningTasks = new Set();
+    const taskPriority = new Map(); // Lower number = higher priority
+    // Will be set when WebSocket connects
+    let currentSocket = null;
+    function processTaskQueue() {
+        if (runningTasks.size >= MAX_CONCURRENT_TASKS || taskQueue.length === 0 || !currentSocket)
+            return;
+        const socket = currentSocket; // Capture non-null reference
+        taskQueue.sort((a, b) => {
+            const priorityA = taskPriority.get(a.taskId) ?? 999;
+            const priorityB = taskPriority.get(b.taskId) ?? 999;
+            return priorityA - priorityB;
+        });
+        const task = taskQueue.shift();
+        if (!task)
+            return;
+        runningTasks.add(task.taskId);
+        if (task.message.type === "edit") {
+            const request = task.message;
+            taskControllers.get(request.taskId)?.abort();
+            const controller = new AbortController();
+            taskControllers.set(request.taskId, controller);
+            if (socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: "Working…" }));
+            }
+            void (0, agent_1.proposeChanges)(cwd, request, task.config, controller.signal, (message, detail, level) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: level === "error" ? "error" : "working", message, detail }));
+                }
+            }, (prompt) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: request.taskId, prompt }));
+                }
+            })
+                .then((proposal) => {
+                if (controller.signal.aborted || socket.readyState !== socket.OPEN)
+                    return;
+                if (!proposalMatchesCurrentSource(cwd, proposal.changes)) {
+                    const refreshAttempts = reviewRefreshAttempts.get(request.taskId) || 0;
+                    const MAX_REFRESH_ATTEMPTS = 3;
+                    if (refreshAttempts < MAX_REFRESH_ATTEMPTS) {
+                        reviewRefreshAttempts.set(request.taskId, refreshAttempts + 1);
+                        setTimeout(() => {
+                            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                                enqueueTask(request.taskId, request, task.config, 0);
+                                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: `The source changed while the proposal was being prepared. Refreshing the review… (${refreshAttempts + 1}/${MAX_REFRESH_ATTEMPTS})` }));
+                            }
+                        }, 500 * (refreshAttempts + 1));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: "The source is still changing after multiple refresh attempts. Stop the dev-server edit or try the request again." }));
+                    }
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "review", message: proposal.summary, changes: proposal.changes }));
+            })
+                .catch((error) => {
+                if (socket.readyState !== socket.OPEN)
+                    return;
+                if (controller.signal.aborted) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "stopped", message: "Agent stopped." }));
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not prepare a change." }));
+            })
+                .finally(() => {
+                if (taskControllers.get(request.taskId) === controller)
+                    taskControllers.delete(request.taskId);
+                runningTasks.delete(request.taskId);
+                taskPriority.delete(request.taskId);
+                processTaskQueue();
+            });
+        }
+        else if (task.message.type === "ask") {
+            const controller = new AbortController();
+            taskControllers.set(task.taskId, controller);
+            socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: "working", message: "Working…" }));
+            void (0, agent_1.answerQuestion)(cwd, {
+                taskId: task.taskId,
+                question: task.message.question,
+                context: task.message.context,
+                element: task.message.element,
+                messages: task.message.messages,
+            }, task.config, controller.signal, (message, detail, level) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: level === "error" ? "error" : "working", message, detail }));
+                }
+            }, (prompt) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: task.taskId, prompt }));
+                }
+            }).then((answer) => {
+                if (!controller.signal.aborted)
+                    socket.send(JSON.stringify({ type: "assistant_message", taskId: task.taskId, message: answer }));
+            }).catch((error) => {
+                if (!controller.signal.aborted)
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not answer." }));
+            }).finally(() => {
+                if (taskControllers.get(task.taskId) === controller)
+                    taskControllers.delete(task.taskId);
+                runningTasks.delete(task.taskId);
+                taskPriority.delete(task.taskId);
+                processTaskQueue();
+            });
+        }
+    }
+    function enqueueTask(taskId, message, config, priority = 0) {
+        taskPriority.set(taskId, priority);
+        taskQueue.push({ taskId, message, config });
+        processTaskQueue();
+    }
     // Fetch workspace configuration from server (dashboard-configured providers)
     let workspaceConfig = null;
     if (lassoKeyConfigured) {
@@ -698,6 +813,7 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     };
     wss.on("connection", (socket) => {
         overlaySocket = socket;
+        currentSocket = socket;
         console.log(chalk_1.default.green("✓") + " Overlay connected");
         const creds = (0, auth_1.loadCredentials)();
         const userInfo = creds?.userName
@@ -712,57 +828,6 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             if (socket.readyState === socket.OPEN)
                 socket.send(JSON.stringify({ type: "git_state", git }));
         });
-        const runEditReview = (request, config, statusMessage) => {
-            taskControllers.get(request.taskId)?.abort();
-            const controller = new AbortController();
-            taskControllers.set(request.taskId, controller);
-            if (socket.readyState === socket.OPEN) {
-                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: statusMessage || "Working…" }));
-            }
-            void (0, agent_1.proposeChanges)(cwd, request, config, controller.signal, (message, detail, level) => {
-                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: level === "error" ? "error" : "working", message, detail }));
-                }
-            }, (prompt) => {
-                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: request.taskId, prompt }));
-                }
-            })
-                .then((proposal) => {
-                if (controller.signal.aborted || socket.readyState !== socket.OPEN)
-                    return;
-                if (!proposalMatchesCurrentSource(cwd, proposal.changes)) {
-                    const refreshAttempts = reviewRefreshAttempts.get(request.taskId) || 0;
-                    const MAX_REFRESH_ATTEMPTS = 3;
-                    if (refreshAttempts < MAX_REFRESH_ATTEMPTS) {
-                        reviewRefreshAttempts.set(request.taskId, refreshAttempts + 1);
-                        setTimeout(() => {
-                            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                                runEditReview(request, config, `The source changed while the proposal was being prepared. Refreshing the review… (${refreshAttempts + 1}/${MAX_REFRESH_ATTEMPTS})`);
-                            }
-                        }, 500 * (refreshAttempts + 1));
-                    }
-                    else {
-                        socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: "The source is still changing after multiple refresh attempts. Stop the dev-server edit or try the request again." }));
-                    }
-                    return;
-                }
-                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "review", message: proposal.summary, changes: proposal.changes }));
-            })
-                .catch((error) => {
-                if (socket.readyState !== socket.OPEN)
-                    return;
-                if (controller.signal.aborted) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "stopped", message: "Agent stopped." }));
-                    return;
-                }
-                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not prepare a change." }));
-            })
-                .finally(() => {
-                if (taskControllers.get(request.taskId) === controller)
-                    taskControllers.delete(request.taskId);
-            });
-        };
         socket.on("message", async (raw) => {
             const msg = JSON.parse(raw.toString());
             if (msg.type === "edit" || msg.type === "ask") {
@@ -871,23 +936,8 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                         serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv),
                     };
                 }
-                socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "working", message: "Working…" }));
-                void (0, agent_1.answerQuestion)(cwd, { taskId: msg.taskId, question: msg.question, context: msg.context, element: msg.element, messages: msg.messages }, selectedConfig, controller.signal, (message, detail, level) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
-                        socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: level === "error" ? "error" : "working", message, detail }));
-                }, (prompt) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
-                        socket.send(JSON.stringify({ type: "agent_prompt", taskId: msg.taskId, prompt }));
-                }).then((answer) => {
-                    if (!controller.signal.aborted)
-                        socket.send(JSON.stringify({ type: "assistant_message", taskId: msg.taskId, message: answer }));
-                }).catch((error) => {
-                    if (!controller.signal.aborted)
-                        socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not answer." }));
-                }).finally(() => {
-                    if (taskControllers.get(msg.taskId) === controller)
-                        taskControllers.delete(msg.taskId);
-                });
+                // Enqueue task for concurrent execution
+                enqueueTask(msg.taskId, msg, selectedConfig, 1); // Priority 1 for ask tasks
             }
             else if (msg.type === "edit") {
                 const localProvider = msg.provider === "cli";
@@ -926,17 +976,29 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 editRequests.set(msg.taskId, msg);
                 editConfigs.set(msg.taskId, selectedConfig);
                 reviewRefreshAttempts.set(msg.taskId, 0);
-                runEditReview(msg, selectedConfig);
+                // Enqueue task for concurrent execution with higher priority (0)
+                enqueueTask(msg.taskId, msg, selectedConfig, 0);
             }
             else if (msg.type === "agent_prompt_response") {
                 (0, agent_1.respondToAgentPrompt)(msg.taskId, msg.response);
             }
             else if (msg.type === "stop") {
-                if (msg.taskId)
+                if (msg.taskId) {
                     taskControllers.get(msg.taskId)?.abort();
-                else
+                    // Remove from queue and running tasks
+                    const queueIndex = taskQueue.findIndex(t => t.taskId === msg.taskId);
+                    if (queueIndex !== -1)
+                        taskQueue.splice(queueIndex, 1);
+                    runningTasks.delete(msg.taskId);
+                    taskPriority.delete(msg.taskId);
+                }
+                else {
                     for (const controller of taskControllers.values())
                         controller.abort();
+                    taskQueue.length = 0;
+                    runningTasks.clear();
+                    taskPriority.clear();
+                }
                 socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "stopped", message: "Agent stopped." }));
             }
             else if (msg.type === "runtime_error") {
@@ -1121,8 +1183,28 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             }
             else if (msg.type === "apply") {
                 try {
+                    // Create snapshot before applying changes
+                    const filePaths = [...new Set(msg.changes.map(c => c.filePath))];
+                    const parentSnapshot = (0, snapshot_1.getSnapshotByTaskId)(cwd, msg.taskId);
+                    // Create pre-apply snapshot
+                    const preSnapshot = (0, snapshot_1.createSnapshot)(cwd, msg.taskId, `Pre-apply: ${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"}`, filePaths, parentSnapshot?.id);
                     const snapshots = [];
                     const planned = new Map();
+                    // Check for conflicts before applying
+                    const expectedFiles = msg.changes.map(change => ({
+                        filePath: change.filePath,
+                        content: change.oldString || null,
+                    }));
+                    const conflicts = (0, snapshot_1.detectConflicts)(cwd, expectedFiles);
+                    if (conflicts.length > 0) {
+                        socket.send(JSON.stringify({
+                            type: "conflict_detected",
+                            taskId: msg.taskId,
+                            conflicts,
+                            message: `Conflict detected in ${conflicts.length} file${conflicts.length === 1 ? "" : "s"}. The source has changed since the suggestion was generated.`
+                        }));
+                        return;
+                    }
                     for (const change of msg.changes) {
                         const isNew = !change.oldString;
                         const filePath = resolveProposedFile(cwd, change.filePath, true);
@@ -1153,6 +1235,8 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                         node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
                         node_fs_1.default.writeFileSync(filePath, nextContent);
                     }
+                    // Create post-apply snapshot
+                    (0, snapshot_1.createSnapshot)(cwd, msg.taskId, `Applied: ${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"}`, filePaths, preSnapshot.id);
                     // Run build validation after applying changes
                     const validation = await validateBuild(cwd);
                     if (!validation.passed) {
@@ -1203,7 +1287,8 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                     const refreshAttempts = reviewRefreshAttempts.get(msg.taskId) || 0;
                     if (sourceChanged && editRequest && editConfig && refreshAttempts < 1) {
                         reviewRefreshAttempts.set(msg.taskId, refreshAttempts + 1);
-                        runEditReview(editRequest, editConfig, "The source changed. Refreshing the review against the current file…");
+                        enqueueTask(msg.taskId, editRequest, editConfig, 0);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "working", message: "The source changed. Refreshing the review against the current file…" }));
                     }
                     else {
                         socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message }));
@@ -1224,9 +1309,117 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 taskSnapshots.delete(msg.taskId || "");
                 socket.send(JSON.stringify({ type: "undone", taskId: msg.taskId, message: snapshots.length ? "The accepted change was reverted." : "There is no accepted change to undo." }));
             }
+            else if (msg.type === "resolve_conflict") {
+                const { taskId, action, conflicts } = msg;
+                if (action === "retry") {
+                    // Re-run the edit request with current file content
+                    const editRequest = editRequests.get(taskId);
+                    const editConfig = editConfigs.get(taskId);
+                    if (editRequest && editConfig) {
+                        reviewRefreshAttempts.set(taskId, 0);
+                        enqueueTask(taskId, editRequest, editConfig, 0);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "working", message: "Retrying with current file content..." }));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: "Could not retry: original request not found." }));
+                    }
+                }
+                else if (action === "force") {
+                    // Force apply despite conflicts (user's choice)
+                    try {
+                        const snapshots = [];
+                        const planned = new Map();
+                        // Get the original changes from the edit request
+                        const editRequest = editRequests.get(taskId);
+                        if (!editRequest) {
+                            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: "Could not force apply: original request not found." }));
+                            return;
+                        }
+                        // Re-prepare changes with current content (may fail, but that's expected)
+                        for (const change of editRequest.changesHistory?.[editRequest.changesHistory.length - 1]?.changes || []) {
+                            const isNew = !change.oldString;
+                            const filePath = resolveProposedFile(cwd, change.filePath, true);
+                            const exists = node_fs_1.default.existsSync(filePath);
+                            const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+                            const prepared = (!exists || isNew)
+                                ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                                : prepareChange(content, change);
+                            const fileChanges = planned.get(filePath) || [];
+                            if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                                throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+                            }
+                            fileChanges.push({ filePath, content, exists, ...prepared });
+                            planned.set(filePath, fileChanges);
+                        }
+                        taskSnapshots.set(taskId, snapshots);
+                        for (const [filePath, changes] of planned) {
+                            const exists = changes[0].exists;
+                            const content = changes[0].content;
+                            snapshots.push({ filePath, content: exists ? content : null });
+                            const nextContent = exists
+                                ? [...changes]
+                                    .sort((a, b) => b.start - a.start)
+                                    .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                                : changes[0].newString;
+                            node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+                            node_fs_1.default.writeFileSync(filePath, nextContent);
+                        }
+                        socket.send(JSON.stringify({
+                            type: "applied",
+                            taskId,
+                            message: "Changes force-applied despite conflicts."
+                        }));
+                    }
+                    catch (error) {
+                        for (const snapshot of taskSnapshots.get(taskId) || []) {
+                            if (snapshot.content === null) {
+                                if (node_fs_1.default.existsSync(snapshot.filePath))
+                                    node_fs_1.default.unlinkSync(snapshot.filePath);
+                            }
+                            else {
+                                node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                            }
+                        }
+                        taskSnapshots.delete(taskId);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "Force apply failed." }));
+                    }
+                }
+                else if (action === "rebase") {
+                    // User wants to rebase - re-run the edit with updated context
+                    const editRequest = editRequests.get(taskId);
+                    const editConfig = editConfigs.get(taskId);
+                    if (editRequest && editConfig) {
+                        reviewRefreshAttempts.set(taskId, 0);
+                        enqueueTask(taskId, editRequest, editConfig, 0);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "working", message: "Rebasing changes against current file content..." }));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: "Could not rebase: original request not found." }));
+                    }
+                }
+            }
+            else if (msg.type === "restore_snapshot") {
+                const success = (0, snapshot_1.restoreSnapshot)(cwd, msg.snapshotId);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    message: success ? "Snapshot restored successfully." : "Failed to restore snapshot."
+                }));
+            }
+            else if (msg.type === "get_timeline") {
+                const timeline = (0, snapshot_1.getTimeline)(cwd);
+                socket.send(JSON.stringify({ type: "timeline", snapshots: timeline }));
+            }
+            else if (msg.type === "delete_snapshot") {
+                const success = (0, snapshot_1.deleteSnapshot)(cwd, msg.snapshotId);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    message: success ? "Snapshot deleted." : "Failed to delete snapshot."
+                }));
+            }
         });
         socket.on("close", () => {
             overlaySocket = null;
+            currentSocket = null;
             console.log(chalk_1.default.yellow("!") + " Overlay disconnected");
         });
     });
@@ -1243,8 +1436,9 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     });
     bridgeServer.listen(bridgePort, "127.0.0.1");
     function send(msg) {
-        if (overlaySocket?.readyState === overlaySocket?.OPEN) {
-            overlaySocket.send(JSON.stringify(msg));
+        const socket = currentSocket;
+        if (socket && socket.readyState === socket.OPEN) {
+            socket.send(JSON.stringify(msg));
         }
     }
     return {

package/dist/cli/oneshot.js

@@ -209,16 +209,13 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
         const isConversational = await isConversationalPrompt(prompt, config, apiKey);
         console.log('[Lasso] Is conversational:', isConversational);
         // Browser inspection & snapshot steps - skip for simple conversational queries
+        // FAST CONTEXT: Skip detailed DOM analysis if pageContext is already provided
         if (pageContext && !isConversational) {
-            onProgress("thinking", "Inspecting browser page...", `Page: "${pageContext.title || "Landing page"}" (${pageContext.route || "/"})`);
+            onProgress("thinking", "Analyzing page context...", `Page: "${pageContext.title || "Landing page"}" (${pageContext.route || "/"})`);
+            // Skip the slow "Scrolling & analyzing" steps - the pageContext already has the data
+            // Only show viewport info if available
             if (pageContext.viewport) {
-                onProgress("thinking", "Capturing visual snapshot...", `Viewport: ${pageContext.viewport.width}x${pageContext.viewport.height} (Document height: ${pageContext.viewport.scrollHeight}px)`);
-            }
-            if (pageContext.domSummary) {
-                const sectionsCount = pageContext.domSummary.sections?.length || 0;
-                const headingsCount = pageContext.domSummary.headings?.length || 0;
-                const buttonsCount = pageContext.domSummary.buttons?.length || 0;
-                onProgress("thinking", "Scrolling & analyzing page sections...", `${sectionsCount} sections, ${headingsCount} headings, ${buttonsCount} CTAs detected`);
+                onProgress("thinking", "Ready to proceed...", `Viewport: ${pageContext.viewport.width}x${pageContext.viewport.height}`);
             }
         }
         else {
@@ -599,47 +596,69 @@ async function analyzeProject(cwd) {
     const hasReact = dependencies.includes("react") || devDependencies.includes("react");
     const hasNext = dependencies.includes("next") || devDependencies.includes("next");
     const hasVite = dependencies.includes("vite") || devDependencies.includes("vite");
-    // Scan directory structure
+    // FAST CONTEXT: Only scan top-level directories, not full recursive scan
+    // This is the key optimization - let the server-side agent handle file discovery
     const files = [];
     const directories = [];
     const appDirs = [];
     const pagesDirs = [];
-    const roots = ["src", "app", "pages", ".", "web", "lib", "components"];
+    const roots = ["src", "app", "pages", "components", "lib"];
     for (const root of roots) {
         const rootPath = node_path_1.default.join(cwd, root);
         if (!node_fs_1.default.existsSync(rootPath))
             continue;
-        const scanDir = (dir, base = "", depth = 0) => {
-            if (depth > 5)
-                return;
-            try {
-                const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".next") {
-                        continue;
-                    }
-                    const rel = base ? node_path_1.default.join(base, entry.name) : entry.name;
-                    if (entry.isDirectory()) {
-                        directories.push(rel);
-                        // Track app and pages directories
-                        if (entry.name === "app")
-                            appDirs.push(rel);
-                        if (entry.name === "pages")
-                            pagesDirs.push(rel);
-                        scanDir(node_path_1.default.join(dir, entry.name), rel, depth + 1);
-                    }
-                    else if (/\.(tsx?|jsx?|vue|svelte|css|html|json)$/i.test(entry.name)) {
-                        files.push(rel);
+        // Only scan top-level (depth 0-1), not recursive
+        try {
+            const entries = node_fs_1.default.readdirSync(rootPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith(".") || entry.name === "node_modules") {
+                    continue;
+                }
+                const rel = entry.name;
+                if (entry.isDirectory()) {
+                    directories.push(rel);
+                    // Track app and pages directories at top level
+                    if (entry.name === "app")
+                        appDirs.push(rel);
+                    if (entry.name === "pages")
+                        pagesDirs.push(rel);
+                    // Only scan one level deep for key directories
+                    if (["components", "lib", "hooks", "utils", "styles"].includes(entry.name)) {
+                        try {
+                            const subEntries = node_fs_1.default.readdirSync(node_path_1.default.join(rootPath, entry.name), { withFileTypes: true });
+                            for (const subEntry of subEntries) {
+                                if (!subEntry.name.startsWith(".") && !subEntry.isDirectory() && /\.(tsx?|jsx?|vue|svelte|css)$/i.test(subEntry.name)) {
+                                    files.push(node_path_1.default.join(rel, subEntry.name));
+                                }
+                            }
+                        }
+                        catch {
+                            // ignore scan errors
+                        }
                     }
                 }
+                else if (/\.(tsx?|jsx?|vue|svelte|css|html|json)$/i.test(entry.name)) {
+                    files.push(rel);
+                }
             }
-            catch {
-                // ignore scan errors
+        }
+        catch {
+            // ignore scan errors
+        }
+        if (files.length > 20)
+            break; // Limit to 20 files for fast context
+    }
+    // Also check root directory for key files
+    try {
+        const rootEntries = node_fs_1.default.readdirSync(cwd, { withFileTypes: true });
+        for (const entry of rootEntries) {
+            if (!entry.isDirectory() && /\.(tsx?|jsx?|vue|svelte|css|html|json)$/i.test(entry.name)) {
+                files.push(entry.name);
             }
-        };
-        scanDir(rootPath);
-        if (files.length > 100)
-            break;
+        }
+    }
+    catch {
+        // ignore scan errors
     }
     // Determine source root
     let sourceRoot = ".";
@@ -649,12 +668,9 @@ async function analyzeProject(cwd) {
         sourceRoot = ".";
     else if (directories.includes("src"))
         sourceRoot = "src";
-    // Detect App Router vs Pages Router
-    const appRouter = appDirs.length > 0 && appDirs.some(dir => {
-        const appPath = node_path_1.default.join(cwd, dir);
-        return node_fs_1.default.existsSync(node_path_1.default.join(appPath, "layout.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(appPath, "page.tsx"));
-    });
-    const pagesRouter = pagesDirs.length > 0 && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_app.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_document.tsx"));
+    // Detect App Router vs Pages Router (lightweight check)
+    const appRouter = appDirs.length > 0 && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "app", "layout.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "app", "page.tsx"));
+    const pagesRouter = pagesDirs.length > 0 && (node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_app.tsx")) || node_fs_1.default.existsSync(node_path_1.default.join(cwd, "pages", "_document.tsx")));
     return {
         framework: (0, framework_1.detectFramework)(cwd),
         hasTypeScript,